发表于   |   分类于   |  

  • 创建django-app(django-blogs)目录,目录下包含项目开发的app(blogsplatform)的所有代码(cp -r blogs/blogsplatform django-blogs)

  • 创建README.md文档 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# Blogs #

Blogs是一个练习django的项目，用来自己博客的管理和查看

Quick Start
----------
1.install app

`pip install blogs`


2.add "blogsplatform" to your INSTALLED_APPS

INSTALLED_APPS = (
    ...,
    'blogsplatform',
)
3.incloud the blogsplatform URLconf in your project urls.py

urlpatterns = [
    ...,
    url(r'^platform/', include('blogsplatform.urls', namespace='blogsplatform')),
]

4.create the models

`python manage.py makemigrations blogsplatfrom`

`python manage.py migrate`

5.run server

`python manage runserver 0.0.0.0:8080`

6.create super user

`python manage.py createsuperuser`

7.visit http://localhost:8080/admin/

8.visit http://localhost:43001/platform/categorylist/
  • 添加证书

创建LICENSE目录，添加证书信息

  • 编写setup.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import os
from setuptools import setup

CURR_PATH = os.path.dirname(os.path.abspath(__file__))
with open(os.path.join(CURR_PATH, 'README.md'), 'r') as readme:
    README = readme.read()

setup(
    name='django-blogs',
    version='0.1',
    packages=['blogsplatform'],
    include_package_data=True,
    license='BSD License',
    description='A simple Django app to blogs',
    long_description=README,
    author='Silence',
    author_email='imsilence@outlook.com',
    classifiers=[
    ],
)

  • 创建MANIFEST.in文档

    用于在生成package包时将LICENSE， README.md等信息打入到package中

    文件内容如下:

1
2
3
4
include LICENSE
include README.md
recursive-include blogsplatform/static *
recursive-include blogsplatform/templates *
  • 生成tar.gz

python setup.py sdist

  • 安装

pip install django-blogs-0.1.tar.gz

  • 卸载

pip uninstall django-blogs

发表于   |   分类于   |  

创建后台管理员

python manage.py createsuperuser

登录后台

访问http://localhost:43001/admin

添加自己的模块到后台管理

在blogs/blogsplatform/admin.py中添加注册

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
from django.contrib import admin

# Register your models here.
from .models import Category, Blog

class BlogStackedInline(admin.StackedInline):
    model = Blog
    extra = 3

class BlogTabularInline(admin.TabularInline):
    model = Blog
    extra = 1
    pass

class CategoryAdmin(admin.ModelAdmin):
    fields = ['category_name', 'create_date']
    inlines = [BlogTabularInline]

    list_display = ('category_name', 'create_date')

class BlogAdmin(admin.ModelAdmin):
    fieldsets = [
        (None, {'fields': ['blog_title', 'blog_content', 'category']}),
        ('Date Information', {'fields': ['create_date'], 'classes':['collapse']}),
    ]

    list_display = ('blog_title', 'blog_content', 'create_date', 'was_created_recently')
    list_filter = ['create_date']
    search_fields = ['blog_title', 'blog_content']


admin.site.register(Category, CategoryAdmin)
admin.site.register(Blog, BlogAdmin)
  • 自定义django admin表单

使用在ModelAdmin中使用方fields指定在表单中显示的表单项

可以使用fieldsets将表单项进行分组

在存在内联关系时，可在被关联的ModelAdmin中使用inlines关联显示其他表的信息

  • 自定义django admin列表

使用list_display控制列表显示列信息

使用list_filter控制过来条件

使用search_fileds指定查询条件

发表于   |   分类于   |  

创建项目

django-admin.py startproject blogs

项目目录结构：

1
2
3
4
5
6
7
blogs
├── blogs
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

说明:

  • manage.py:django命令行工具
  • settings.py:项目设置
  • urls.py:项目url配置
  • wsgi.py:项目web访问入口

数据库配置

  • 配置文件:blogs/blogs/settings.py

DATABASES 属性用户配置项目使用的数据库，可配置多个:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    },
    'mysql': {
        'ENGINE'： 'django.db.backends.mysql',
        'NAME'： 'blogs',
        'USER'： 'user',
        'PASSWORD'： 'pwd',
        'HOST'： 'localhost',
        'PORT'：3306
    }
}

数据库配置说明：

ENGINE: 用于指定数据库驱动
NAME： 数据库名称，若使用sqlite则为sqlite文件路径
USER： 数据库连接用户名
PASSWORD： 数据库连接密码
HOST： 数据库连接主机地址
PORT： 数据库连接端口号

  • 数据库逆向创建

若使用非sqlite数据库，则需要在逆向创建数据表前使用CREATE DATABASE dbname创建数据库,然后在使用python manage.py migrate逆向创建数据表

启动服务

python manage.py runserver 0.0.0.0:43001

创建应用

  • 初始化应用

python manage.py startapp blogsplatform

目录结构如下：

1
2
3
4
5
6
7
8
blogsplatform/
├── admin.py
├── __init__.py
├── migrations
│   └── __init__.py
├── models.py
├── tests.py
└── views.p

  • 添加应用到项目中

在blogs/blogs/setting.py的INSTALLED_APPS属性中添加创建的应用名称

1
2
3
4
5
6
7
8
9
INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blogsplatform',
)

  • 创建 models

在blogsplatform/models.py中编辑文件创建db操作类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from django.db import models


class Category(models.Model):
    category_name = models.CharField(max_length=250)
    create_date = models.DateTimeField('date created')

    def __unicode__(self):
        return '%s:%s:%s' % (self.id, self.category_name, self.create_date)


class Blog(models.Model):
    blog_content = models.TextField()
    create_date = models.DateTimeField('date created')
    category = models.ForeignKey(Category)

    def __unicode__(self):
        return '%s:%s:%s:%s' % (self.id, self.category.category_name, self.blog_content, self.create_date)
  • 同步数据库

生成migrations文件，用于通知django自己的model发生的变化

python manage.py makemigrations blogsplatform

查看sql语句

`python manage.py sqlmigrate blogsplatform 0001

同步数据库表

python manage.py migrate

django shell

django shell是django操作的一个命令行接口，启动时已初始化django环境

python manage.py shell

操作如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
In [1]: from blogsplatform.models import Category, Blog

In [2]: from django.utils import timezone

In [3]: category = Category(category_name='生活随笔', create_time=timezone.now())

In [4]: category = Category(category_name='生活随笔', create_date=timezone.now())

In [5]: category.save()

In [6]: Category.objects.all()

Out[6]: [<Category: 1:生活随笔:2015-05-26 01:05:21.191538+00:00>]

In [8]: category.blog_set.all()

Out[8]: []

In [9]: blog = category.blog_set.create(blog_content='test', create_date=timezone.now())

In [17]: Blog.objects.count()

Out[17]: 1

In [18]: blog.blog_content

Out[18]: 'test'

In [19]: blog.blog_content = 'test1'

In [20]: Blog.objects.all()

Out[20]: [<Blog: 1:生活随笔:test:2015-05-26 01:09:07.316380+00:00>]

In [21]: blog.save()

In [22]: Blog.objects.all()

Out[22]: [<Blog: 1:生活随笔:test1:2015-05-26 01:09:07.316380+00:00>]

In [23]: blog2 = Blog(blog_content='test2', create_date=timezone.now(), category=category)

In [24]: blog2.save()

In [25]: Blog.objects.filter(pk=2)
Out[25]: [<Blog: 2:生活随笔:test2:2015-05-26 01:16:24.733357+00:00>]

In [26]: category.blog_set.count()
Out[26]: 2

In [27]: tblog2 = category.blog_set.get(pk=2)

In [28]: tblog2.delete()

In [29]: Blog.objects.get(pk=2)

In [31]: Blog.objects.filter(blog_content__startswith='test')

Out[31]: [<Blog: 1:生活随笔:test1:2015-05-26 01:09:07.316380+00:00>]

发表于   |   分类于   |  

Docker是什么

Docker是基于LXC（Linux容器）实现的一种操作系统级别的虚拟化技术

Ubuntu安装

sudo apt-get install -y docker.io

版本查看

sudo docker version

镜象

镜象可以理解为Docker中的一个只读的模板，用来创建容器

  • 查找镜象

sudo docker search registry.hub.docker.com/ubuntu

  • 获取镜象

‵sudo docker pull registry.hub.docker.com/ubuntu:14.04`

  • 列出本地所有镜象

sudo docker images

  • 运行镜象创建容器

sudo docker run -t -i ubuntu:14.10 /bin/bash

  • 创建镜象

在启动的容器中安装需要的程序后,退出容器(命令exit),使用docker commit将容器创建为镜象

sudo docker commit -m "add nginx program" -a "Silence UK" container_id ubuntu/nginx:v1

  • 从本地导入文件创建镜象

模板下载地址: templates

目前hub.docker.com上提供的镜象为x64,若本地为x86系统,只能从templates下载模板自行创建镜象

sudo cat ubuntu "ubuntu-14.10-x86.tar.gz" | docker import - ubuntu:14.10

  • 存入和载出镜象

sudo docker save -0 ubuntu-14.10.tar ubuntu:14.10

sudo docker load --input ubuntu-14.10.tar

  • 删除镜象

sudo docker rmi ubuntu:14.10

  • 原理

利用unionfs（支持将不同目录挂在到同一虚拟文件系统下的文件系统）

容器

容器是从镜象创建的运行实例，是一个独立运行的linux环境

  • 启动容器

启动容器有两种方法，一种为根据镜象创建并启动容器，另一种为将已停止的容器重新启动

sudo docker run -i -t ubuntu:14.10 /bin/bash

sudo docker start container_id|container_name

  • 运行守护

sudo docker run -d ubuntu:14.10 /bin/sh "while true; do echo hello, docker; sleep 1;done"

  • 查看log

sudo docker logs container_id|container_name

  • 进入容器

sudo docker attach container_id|container_name

  • 停止容器

sudo docker stop container_id|container_name

  • 查看所有容器

sudo docker ps -a

  • 保存和导入容器

sudo docker export cantainer_id|container_name > nginx.tar

sudo cat nginx.tar | docker import - nginx:v1

  • 删除容器

sudo docker rm container_id|container_name

仓库

仓库用来做镜象的存储

数据管理

  • 数据卷

数据卷是可供一个或多个容器同时使用的特殊目录

sudo docker run -t -i --name testv -v /home/silence/Documents/github/docker:/tmp/ ubuntu:14.10 python /tmp/t.py

加载本地磁盘目录/home/silence/Documents/github/docker到容器的/tmp/目录

网络

  • 外部访问容器

使用参数-P或-p用于将本地的端口映射到容器的端口上

sudo docker run -d -p 42001:80 ubuntu:14.10 /bin/bash