Shulou(Shulou.com)06/01 Report--

This article is about how to use Docker-compose to deploy Django applications offline. The editor thinks it is very practical, so share it with you as a reference and follow the editor to have a look.

Our intranet environment needs to deploy a CMS-like application, that is, some tabular CRUD, data export, personnel rights management and other functions. Thinking that Django is good at doing this work, and the amount of development is not large, so choose Django as the basis of development. The development function is relatively simple, almost using plug-ins such as xadmin to achieve the above functions. However, there is a problem that we can't get around, that is, when we deploy to a private network environment, tools such as private network pip cannot be used, but fortunately, there is a yum server available in the private network, so we decided to install Docker on the private network server, and then copy the container of the development environment to the production environment for deployment. The following are the main steps:

Install Docker-ce for the development environment

Install Docker-compose for the development environment

Configure the development environment

Save Container

Install Docker-ce and docker-compose for production environment

Send the container file and run

Note: my development environment here is Ubuntu18.04, and my production environment is Centos7.2. If you are in another environment, please check the differences yourself and use the commands that suit your system.

Install Docker-ce for the development environment

Docker and Docker-compose are what we need to focus on in this deployment, and I will try my best to reduce the application part of Django. Docker is responsible for the underlying part of container virtualization. Docker-compose is a container orchestration tool that eliminates the need for handwritten shell to implement connections between containers. Let's install Docker-ce first. Here we mainly refer to the official documentation of Docker. If I am not detailed enough or out of date, you can check the official documentation for more authoritative updates.

Uninstall the old version

You need to uninstall the old version of docker before installing it. If you are a new system, you can ignore this step.

$sudo apt remove docker docker-engine docker.io containerd runc

Install the apt repository used

Update the apt package index

$sudo apt update

Allow apt to access the warehouse through https

$sudo apt install\ apt-transport-https\ ca-certificates\ curl\ gnupg-agent\ software-properties-common

Add the official GPG key of Docker

$curl-fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add-

Increase the warehouse of Docker

$sudo add-apt-repository\ "deb [arch=amd64] https://download.docker.com/linux/ubuntu\ $(lsb_release-cs)\ stable"

Install Docker-ce

After making the above preparations, it is easy to install Docker-ce. If you are familiar with Ubuntu, you can install it soon.

$sudo apt update$ sudo apt install-y docker-ce

After the installation is complete, start the docker service and enable it to start each time the system boots.

Sudo systemctl start docker$ sudo systemctl enable docker installs the Docker-compose of the development environment

After the Docker-ce installation is complete, Docker-compose is easy to do. If you are directly downloading Docker-compose 's compiled binaries on platforms such as Linux, you can use it.

The copy code is as follows:

$sudo curl-L "https://github.com/docker/compose/releases/download/1.23.2/docker-compose-$(uname-s)-$(uname-m)"-o / usr/local/bin/docker-compose

Modify permission plus executable after download is completed

$sudo chmod + x / usr/local/bin/docker-compose

Finally, you can check the version number of Docker-compose to verify whether the installation is successful.

$docker-compose-- versiondocker-compose version 1.24.0-rc1, build 0f3d4dda configuration development environment

The development environment here is the Django environment, the demonstration project I try to use a new Django project to facilitate the demonstration.

Create a new Django project

To create a new Django project, first create an upper-level folder to put the project files in this folder. The directory structure is roughly as follows:

-project-- Dockerfile-- docker-compose.yml-- mysite-- manage.py-- requirements.txt

Create a project folder first

$mkdir project

Then create a new Django project, or you can copy the existing project.

$django-admin.py startproject mysite

Generate requirements.txt file

In the previous step, we already have a Django project called mysite. Suppose we put requirements.txt under this folder, which is roughly as follows:

$cat requirements.txtdefusedxml==0.5.0diff-match-patch==20181111Django==2.1.7django-crispy-forms==1.7.2django-formtools==2.1django-import-export==1.2.0django-reversion==3.0.3et-xmlfile==1.0.1future==0.15.2httplib2==0.9.2jdcal==1.4odfpy==1.4.0openpyxl==2.6.0pytz==2018.9PyYAML==3.13six==1.10.0tablib==0.12.1unicodecsv==0.14.1xadmin==0.6.1xlrd==1.2.0xlwt==1.3.0mysqlclient==1.4.2

Of course, this is the dependence that my project needs, and your dependence may be different from mine.

Create a new Dockerfile

Now that we have the project and the dependent files of the project, the next step is to create a docker image of the running environment of our Django project, and first build a Dockerfile to build the docker image. Create a new Dockerfile in the project folder as follows:

$cat DockerfileFROM python:3.6.8ENV PYTHONUNBUFFERED 1RUN mkdir / configADD / mysite/requirements.txt / config/RUN pip install-r / config/requirements.txtRUN mkdir / srcWORKDIR / src/mysite

Let me explain this file briefly.

FROM python:3.6.8

The basic image I use here is python:3.6.8, and its basic image is Ubuntu. I am familiar with it. If you are familiar with alpine, you can also use alpine. That image is much smaller.

ENV PYTHONUNBUFFERED 1

You can use the Env keyword to create any environment variable of the operating system

ENV PYTHONUNBUFFERED 1

For example, if you use it to store your Django key, you can write:

ENV DJANGO_SECRET_KEY lumped fafmjcqynism joczz1 # 2wtfolo8w8k (_ dhgub%41l#k3zi2m-b%m

Use it in your code like this:

Import osSECRET_KEY = os.environ ['DJANGO_SECRET_KEY']

RUN as its name implies, RUN runs commands in the container, where the RUN command creates two folders / config and / src, as well as the dependent environment in which Python is installed.

RUN mkdir / configRUN mkdir / srcRUN pip install-r / config/requirements.txt

ADD

ADD / mysite/requirements.txt / config/

Add local files to the container WORKDIR

WORKDIR / src/mysite

Is to specify the default path for all subsequent commands to run in the container, which can be seen later in the docker-compose file.

Create a new docker-compose script

Docker-compose can be used to manage multiple containers. In the past, docker-compose can do the work of manually adding a large number of parameters to run containers and connect containers. My docker-compose.yml is roughly as follows:

$cat docker-compose.ymlversion: '3'services: db: image: mysql:5.7 container_name: mysite_db ports:-"3306 image 3306" environment: MYSQL_ROOT_PASSWORD: mysite MYSQL_DATABASE: mysite LANG: C.UTF-8 web: build:. Container_name: mysite_web command: bash-c "python manage.py makemigrations & & python manage.py migrate & & python manage.py runserver 0.0.0.0 python manage.py makemigrations 8000" depends_on:-db volumes: -. / mysite:/src restart: always ports:-"8002 python manage.py makemigrations 8000"

Explain the docker-compose file briefly again.

Version:'3'

Refers to the version of docker-compose, and different versions support slightly different configuration items. The services managed by services, in our example, are two services: db and web. Let me explain the configuration items in the two services separately: db:

Image directly uses docker hub or a local existing image. In this case, MySQL5.7 container_name specifies the name of the container, ports specifies the port mapping of the container to the host, the front is the host port, and the container port environment specifies the environment of the current service runtime. For details of the environment, refer to the description of the current image. We can configure what is supported above. In this case, we specified the root password of MySQL, the default database, and the character set of the database. Web: build compiled image. Here is the service that depends_on the current container depends on using the command executed after starting the Dockerfile command container under the current folder, that is, you must start the current service successfully to start the volume to be mounted by the volumes current container. The previous refers to the directory of the host, followed by the container directory restart that specifies the restart policy of the container. The current case is to keep restarting if something goes wrong. Here, port 8000 of the container is mapped to port 8002 of the host, and the web service is accessed from port 8002.

Configure the Django project

Now modify the settings.py file of the mysite project for the current container environment.

$vim mysite/mysite/settings.py

Locate the ALLOW_HOSTS section of the file and add "web" to it, as follows:

ALLOW_HOSTS = [... 'web']

Then modify the DATABASES section of the settings.py to change the parameter to the parameter of the MySQL service db, which is roughly as follows:

DATABASES = {'default': {' ENGINE': 'django.db.backends.mysql',' NAME': 'mysite',' USER': 'root',' PASSWORD': 'mysite',' HOST': 'db'}}

The MySQL connection parameters here are defined in environment in the db section of the docker-compose.yml file. It is worth pointing out that when the parameter host value is db,docker-compose, these containers will be connected, and the containers can use service names to ping each other, just like using domain names, so the "HOST" here can be entered directly as "db".

Build a project using Docker-compose

After the above efforts, we are basically ready to construct our image. Here are two services. Db only needs to download or use the local image at run time, and web needs to be built using Dockerfile.

$docker-compose build

After a while of downloading or building, you can see the information about the successful construction of the image.

Run the project and test it

After the build is complete, you have a mirror of the web service, and we now use docker-compose to start the service.

$docker-compose up-d

This process may also take a while, depending on your network speed, it downloads the image of MySQL, constructs the container from the image of db and web, and runs the container. When you are finished, you can use docker-compose ps and docker-compose images to view our generated containers and images.

$docker-compose psName Command State Ports-mysite_db docker-entrypoint.sh mysqld Up 0.0.0.0VOVA 3306-> 3306/tcp 33060/tcpmysite_web bash-c python manage.py m... Up 0.0.0.0 MBmysite_web mysite_web latest 3989acbcc3c9 8002-> 8000 Compact TCP $docker-compose imagesContainer Repository Tag Image Id Size---mysite_db mysql 5.7 e47e309f72c8 355 MBmysite_web mysite_web latest 3989acbcc3c9 938 MB

You can also use docker-compose to stop and start services. For more specific uses, please refer to the official documentation.

$docker-compose startStarting db... DoneStarting web... Done$ docker-compose stopStopping mysite_web... DoneStopping mysite_db... Done

You can see that the order in which the services are stopped and started here is that the dependent service starts first and then starts the dependent service, while the value service is just the opposite. After the service is running normally, you can visit the browser to test whether the service starts normally.

Save Container

If all goes well with the service, we need to save the current container in preparation for deployment to the new platform. Note:   uses save to save the image. Using save includes information such as the connection status between containers. If you export the image to the production environment using export, you cannot use docker-compose to restore the service.

$docker save-o mysql.tar mysql:5.7$ docker save-o mysite.tar mysite_web:latest

When the above command is executed successfully, two tar files are generated in the current directory, plus the Dockerfile and docker-compose.yml files of the project directory are put together to be migrated to the production machine.

Install Docker-ce and docker-compose for production environment

Since the production environment is CentOS, you can install it directly using yum

$sudo yum install docker-ce

After the installation is successful, refer to the development environment and deploy docker-compose to the production server.

Send the container file and run

Use scp or other tools to send mysql.tar, mysite.tar, Docker-compose.yml, and project folders to the production server, and find a suitable folder to store these files, maintaining the original directory structure. Let's restore two images to the production server first.

$docker load-I mysql.tar$ docker load-I mysite_web.tar

Wait a little while for the execution to complete, and you can see that the current server already has these two images.

REPOSITORY TAG IMAGE ID CREATED SIZEmysite_web latest 3989acbcc3c9 2 days ago 983MBmysql 5.7 e47e309f72c8 3 weeks ago 372MB

We also need to make a simple change to docker-compose.yml before building the container. You have also noticed that the production server does not have the Internet, so you can no longer build the image, and we have copied the image of the development environment as is, so this time the web service can be run from the image instead, and the content is roughly as follows:

Version: '3'services: db:... web: image: mysite_web:latest.

Just change the build entry in web and delete it, and add an image entry, and the content is the image we copied. Later we can build the container and start the service.

$docker-compose up-d

Result

Name Command State Ports-mysite_web bash-c python manage.py m... Up 0.0.0.0 3306/tcp 8002-> 8000/tcp mysite_db docker-entrypoint.sh mysqld Up 0.0.0.0 VR 3306-> 3306/tcp, 33060/tcp

Open the browser again to see if it starts normally.

Thank you for reading! This is the end of the article on "how to deploy Django applications offline using Docker-compose". I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, you can share it for more people to see!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.