Liberação de código do Docker

Introdução ao Docker:

1. Comparado às máquinas virtuais, o Docker possui uma pequena ocupação de espaço, uma velocidade de inicialização rápida (em segundos) e um alto grau de integração , o que pode efetivamente evitar problemas de incompatibilidade de versão.

2. O que é o espelhamento : O espelhamento é a unificação de várias camadas somente leitura, exceto que a camada inferior não aponta, cada camada aponta para a camada pai. A tecnologia do sistema de arquivos unificado (Union? File System) pode integrar camadas diferentes em um sistema de arquivos, fornecendo uma perspectiva unificada para essas camadas, ocultando a existência de várias camadas. Da perspectiva do usuário, existe apenas um sistema de arquivos. Cada camada do espelho não é gravável e é uma camada somente leitura.
   O que é um contêiner : a definição de um contêiner é quase a mesma que uma imagem e também é uma visão unificada de uma pilha de camadas.A única diferença é que a camada superior do contêiner é legível e gravável. Pontos principais: container = espelho + camada de leitura e gravação, e a definição do container não menciona se o container deve ser executado.
   Recomenda-se voltar depois do treino para entender a diferença entre contêineres e imagens do docker

3. Operações comuns
   imagens do docker: exibir todas as imagens
   docker rmi id-da-imagem: excluir imagens
   docker ps -a: exibir todos os contêineres
   docker rm container-id: excluir contêineres
   docker anexar ID do contêiner: entrar no contêiner (agora use basicamente exec, saia sem fechar o contêiner )
   Docker registra ID do contêiner Visualizar a saída interna da
   janela de encaixe Container tag imageid: tag name: tag Modifique o nome da imagem
   docker commit: Converta a camada de leitura e gravação do contêiner em uma camada somente leitura, para que um contêiner seja convertido em uma imagem imutável .

4. alpino

Texto: Lançamento do projeto Django

1. Crie uma árvore de arquivos

compor
——lineline (offline)
—Dockerfile (arquivo de imagem de compilação)
—pip.conf (velocidade de download acelerada do pip)
—AIRS (arquivo de projeto
)
—requirements.txt ( diretório de instalação) —start.sh (arquivo de inicialização)
—upline (Online)
2. clone .git *** Armazene o arquivo do projeto em AIRS
3. .cp ./AIRS/requireme ./requirements Salve o arquivo de requisitos a ser instalado no mesmo diretório que o Dockerfile
4. Escreva o arquivo pip.conf vim pip .conf

[global]
index-url = http://mirrors.aliyun.com/pypi/simple/
[install]
trusted-host=mirrors.aliyun.com
~                                                        

5. Escreva start.sh vim start.sh

python manage.py runserver 0.0.0.0:8000

6. Escreva Dockerfile

#基础镜像 docker pull python:3.6
FROM python:3.6		
#定义环境变量
ENV PYTHONUNBUFFERED 1
#将pip.con转移到新镜像的 /root/.pip/pip.conf
COPY pip.conf /root/.pip/pip.conf
#将项目存放到/app文件夹下
COPY AIRS/ /app
#将需要下载的requirements.txt放入工作目录/app下
COPY requirements.txt /app/requirements.txt
#开始下载依赖包
RUN pip install -r /app/requirements.txt
#确定工作目录
WORKDIR /app

#将启动文件放入镜像
copy ./start.sh /app/start.sh
RUN chmod +x /app/start.sh
CMD ["sh", "start.sh"]

7. Crie uma imagem

#docker build -t="用户名/镜像名称:版本（tag) "   .(当前目录)
docker build -t="horn/airs:v1.0" .

8. Inicie o contêiner

#-d 后台运行
#-i 打开STDIN，用于控制台交互
#-t 分配tty设备，该可以支持终端登录，默认为false
#-p  指定容器暴露的端口
#-u 指定容器的用户
#--name 给容器起别名
[root@horn downline]# docker run -d -p 1935:8000  horn/airs:v1.0  python manage.py runserver 0.0.0.0:8000
#显示所有容器
docker ps -a 

9. Inicialização bem-sucedida, mas inacessível externamente
Método 1: Modifique os arquivos no contêiner, copiando, desvantagens (problemas)

#将当前目录settings.py 复制到 containerid:/app/推荐系统/settings.py
docker cp ./settings.py 7ed:/app/推荐系统/settings.py

Método 2: entrar diretamente no contêiner para modificar o arquivo de configuração, a desvantagem é que o vim precisa ser instalado, aumentando a área ocupada pelo contêiner

docker run -i –t centos /bin/bash
or
docker exec  -it container-id /bin/bash  
#获取docker镜像root权限
sudo docker exec -ti -u root container-id  /bin/bash 

#退出后重启容器： docker restart container

10. Logon do docker do armazém do Docker
(1)

(2) Modifique o nome da imagem de acordo com a conta da janela de encaixe-> nome de usuário / nome da imagem

docker tag imageid:tag name:tag

(3) Armazene a imagem no armazém da janela de encaixe

docker push 用户名/镜像名

11. Modifique a imagem

sudo docker commit -m 'modify settings.py' -a "docker horn1998" 9c54 horn1998/airs:v2.0
Entre eles, -m para especificar as informações de descrição enviadas, as mesmas que a ferramenta de controle de versão que usamos; -a pode especificar as informações atualizadas do usuário; seguidas pelo ID 9c54 do contêiner usado para criar o espelho ; finalmente, especifique o nome do armazém do espelho de destino e as informações da etiqueta . Após a criação bem-sucedida, as informações de ID desta imagem serão retornadas .
12. docker-compose
1. Instalação rápida

curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
docker-compose --version

2. Interpretação Variável

• image: Especifique o nome ou ID da imagem. Se a imagem não existir localmente, o Compose tentará puxar a imagem

image: python:3.6-alpine

• build: constrói uma imagem baseada no Dockerfile
  • args: defina as variáveis ​​de ambiente necessárias no arquivo sh durante o processo de compilação, mas serão canceladas após o êxito da compilação

e1:build: .	#当前目录下寻找Dockerfile，如果同时指定了build, image，则Compose会构建镜像并且把镜像命名为image对应的名字
e2:build:
		context:.
		args:
			build:1	
			password: secret		

• comando: pode substituir o comando padrão executado após o contêiner ser iniciado

command: python manage.py runserver 0.0.0.0:8000

• depende_on: a sequência de inicialização do contêiner é necessária, controle a sequência de inicialização do contêiner para evitar falhas na inicialização devido a problemas de dependência do contêiner

depends_on:
	-db #其它服务名称

• CMD: Depois de iniciar o contêiner, forneça os comandos e parâmetros padrão (não necessariamente serão executados, mas o padrão) será o docker executado atrás dos parâmetros para substituir o
  CMD para fornecer alguns comandos e parâmetros quando o contêiner estiver em execução, o uso é o seguinte: O
  primeiro uso: execute um executável Arquive e forneça parâmetros.
  CMD ["sh", "start.sh"]
  O segundo uso: especifique parâmetros para ENTRYPOINT.
  CMD ["param1", "param2"] O
  terceiro uso (formato de shell): o comando executado pelo método "/ bin / sh -c".
  CMD ["/ bin / echo", "este é um teste de eco"]
  Um arquivo docker pode ter no máximo um cmd, se houver vários, apenas o último entrará em vigor.

• ENTRYPOINT: executado quando o contêiner é iniciado (será executado)

• A diferença entre o ponto de entrada e o cmd
  geralmente é o colchete de entrada na forma de colchetes, como o comando de execução padrão após o início do contêiner do docker, que contém a parte inalterada; a parte variável, como o parâmetro de comando, pode usar o formato de cmd para fornecer a versão padrão O parâmetro padrão usado quando não há parâmetro em execução. Se queremos usar os parâmetros padrão, corremos diretamente, caso contrário, queremos usar outros parâmetros, adicione parâmetros para executar.
  Link original: https://blog.csdn.net/u010900754/article/detaills/78526443

• external_links: conecte-se a contêineres que não estão mais definidos no docker-compose.yml
• links: resolver o problema de conexão entre contêineres
• ports: o rótulo da porta mapeada

ports:
		- "8000:8000"

• O
  volume do volume garante a persistência dos dados do Docker, mesmo que os dados não terminem com o final do contêiner, os dados existem na máquina host - existem em um diretório especificado do host ou usam o volume gerenciado pelo próprio Docker.

volumes:	
		#此时docker将自动创建一个匿名的volume，并将其挂载到container中的/mysql目录。
		- /var/lib/mysql
		#如果文件不存在，则docker会自动创建
		- /opt/data:/var/lib/mysql

3. Código de exemplo

version: '2'
services:
                ssm:
                        build: .
                        ports:
                                - "1935:8000"
                        image: horn1998/ssm:v2.0
                        command: sh start.sh
                        depends_on:
                               - mysql
                        volumes:
                               - /opt/data:/app/data
                        links:
                               - mysql
                mysql:
                        image: mysql:latest
                        ports:
                                - "3306:3306"
                        command: service mysql start

4. Comece a escrever:

docker-compose up -d