Docker Compose Tutorial

A popularidade do Docker como ferramenta de desenvolvimento está em ascensão. Docker deu uma nova vida no movimento do contêiner. Desenvolvedores gostam de usá-lo porque é rápido e fácil de aprender. Ajuda as equipes de desenvolvimento a compartilhar ambientes padrão sem se preocupar em perder tempo e recursos.

Os desenvolvedores podem configurar o ambiente desejado em um contêiner do Docker, salve o contêiner como uma imagem e compartilhe -a facilmente com suas equipes de desenvolvimento. O processo funciona muito bem para um único contêiner. No entanto, ambientes multi-containers são mais difíceis de manter. Docker Compose fornece a solução.

Com o Docker Compose, os desenvolvedores podem definir um arquivo YAML para configurar a configuração para vários serviços. Em seguida, eles podem iniciar os serviços multi-container com um único comando. Ele simplifica o processo de trabalho com aplicativos multi-containers.

Pré -requisito

Estamos assumindo que você tem um entendimento básico do Docker. Caso contrário, olhe para Como instalar e usar o Docker no Ubuntu. Os exemplos usam WordPress, MySQL, Flask e Python. No entanto, nenhum conhecimento prévio dessas ferramentas é necessário.

Processo de composição do Docker: de relance

1. Defina o ambiente de aplicativo: Use DockerFile para definir o ambiente de aplicativos para torná -lo facilmente reproduzível.
2. Defina o ambiente de composição do docker: Use Docker-Compose.YML para definir os serviços no aplicativo.
3. Execute o aplicativo: Use o Docker-Compose Up para executar o aplicativo multi-container.

Exemplo de arquivo de composição do docker

Versão: '3'

Serviços:

DB:

Imagem: MySQL: 5.7

volumes:

- db_data:/var/lib/mysql

Reinicie: sempre

ambiente:

Mysql_root_password: rootpassword123

Mysql_database: wordpress

Mysql_user: wordpress_user

Mysql_password: wordpress_password

WordPress:

depende de:

- dB

Imagem: WordPress: mais recente

Portas:

- "8000: 80"

Reinicie: sempre

ambiente:

Wordpress_db_host: db: 3306

Wordpress_db_user: wordpress_user

Wordpress_db_password: wordpress_password

volumes:

db_data:

Se o Docker-Compose acima.O arquivo YML é chamado com o Docker Up, ele criará um serviço WordPress que se conecta a um serviço de banco de dados MySQL.

Docker Compõe comandos

Você pode usar DOCKER -COMPOSE -HELP Para encontrar o comando Docker Compose

Quando usar o Docker compor?

Atualmente, o Docker é usado principalmente em ambientes de desenvolvimento. Alguns dos usos populares do Docker Compose são:

1. Prototipagem e desenvolvimento

O processo de prototipagem e desenvolvimento de aplicativos é desacelerado devido à falta de ambientes padrão. Os desenvolvedores geralmente precisam perder tempo configurando o mesmo ambiente várias vezes. Além disso, a leitura dos guias para configurar parâmetros do ambiente é demorado.

Docker compor simplifica o processo. Depois que um ambiente é configurado, as equipes de desenvolvimento podem compartilhar os arquivos do Docker em toda a organização. Pode economizar uma quantidade enorme de tempo desperdiçado em problemas de gerenciamento de configurações.

2. Testando e automatizando processos

Integração contínua e entrega contínua (IC/CD) estão se tornando processos padrão nos ambientes de desenvolvimento ágil de hoje. O teste automatizado é um componente importante do CI/CD. Docker Compose ajuda a definir o processo de teste automatizado. Todas as complicações de iniciar novos serviços podem ser colocadas perfeitamente em arquivos de configuração do Docker. Os testadores podem usar esses arquivos para iniciar serviços temporários, executar scripts de texto e destruir os serviços depois de coletar os resultados do teste. Economiza tempo porque os serviços iniciantes manualmente são demorados e propensos a erros.

3. Futura implantação de produção

Docker é usado principalmente em ambientes de desenvolvimento. No entanto, à medida que as funcionalidades do Docker se tornam mais robustas, o Docker será usado para mais trabalho no nível da produção. Docker Compose pode ser uma ferramenta valiosa para implantações de host único.

Exercício: um aplicativo da web simples

Vamos tentar nossa mão em um simples aplicativo da web baseado em Python para experimentar o Docker Compose. Usaremos a estrutura da web do Flask para criar um aplicativo que se comunique com um banco de dados em memória redis para acompanhar quantas vezes o aplicativo da web foi visitado.

A estrutura do diretório ficará assim:

Simple_app

├── Conteúdo

│ ├── Dockerfile

│ └── Código

│ ├── Simple_App.py

│ └── Requisitos.TXT

└── Docker-Compose.yml

A estrutura de diretório acima não é necessária para um aplicativo básico. No entanto, mostra como a organização de informações pode ser útil para uma implementação mais eficiente do docker compor.

Etapa 1: Crie estrutura e arquivos de diretório

Vamos criar a estrutura do diretório e os arquivos necessários:

$ mkdir simples_app

$ mkdir simples_app/conteúdo

$ mkdir simples_app/content/code

$ touch simples_app/docker-composição.yml

$ touch simples_app/content/dockerfile

$ touch simples_app/content/code/simples_app.py

$ touch simples_app/content/code/requisitos.TXT

O comando Touch está apenas criando arquivos vazios. Você pode entrar manualmente nas pastas e criar os arquivos.

Etapa 2: código de aplicativo da web

A pasta de código contém o código do aplicativo da web. Coloque o seguinte Simple_app.py arquivo:

do frasco de importação de frascos

De Redis Import redis

App = Flask (__ nome__)

redis = redis (host = 'redis', porta = 6379)

@aplicativo.rota('/')

def hello ():

contagem = redis.inc ('hits')

retornar 'Bem -vindo ao Docker compor lições! Você visitou este site tempos.\ n '.formato (contagem)

Se __name__ == "__main__":

aplicativo.Run (host = "0.0.0.0 ", Debug = true)

O aplicativo acima cria uma página de boas -vindas que exibe o número de vezes que a página foi visitada. O contador da visita é mantido em um banco de dados Redis. Redis usa a porta 6379 como sua porta de escuta padrão. Em seguida, preencha o requisitos.TXT arquivo:

frasco

Redis

Isso permitirá que o PIP instale dependências python no contêiner da web. Vamos executar o PIP como parte de inicializar nosso serviço.

Etapa 3: Dockerfile

Preencha o Simple_app/Content/Dockerfile com o seguinte código:

De Python: 3.6.3-Jessie

ADICIONAR ./código /código

WorkDir /Code

Execute os requisitos de instalação do PIP.TXT

CMD ["Python", "Simple_app.py "]

O de cima Dockerfile alcança o seguinte:

1. Cria uma imagem de Python: 3.6.3-Jessie. Se não estiver disponível localmente, o download do Docker Hub.
2. Copia os elementos em Simple_app/content/código em /código no recipiente
3. Definir /código como diretório de trabalho no contêiner
4. Usa o PIP para instalar as dependências do Python
5. Define o ponto de partida padrão para o contêiner executar python simples_app.py.

Etapa 4: Docker Compose

Preencha o Simple_app/Docker-Compose.yml Arquivo com o seguinte código:

Versão: '3'

Serviços:

rede:

construir: ./contente

Portas:

- "5000: 5000"

volumes:

- ./Content/Code:/Code

Redis:

Imagem: "Redis: Alpine"

O Docker-Compose.yml O arquivo define dois contêineres: Web e Redis. Ele usa formato Docker Compose versão 3.

Para o serviço da web:

• Construa o serviço da web usando Simple_app/Content/Dockerfile
• Ataque para encaminhar 5000 do contêiner da web para a porta 5000 do host. Porta 5000 é a porta padrão para aplicações de frasco.
• Volume Simple_app/content/código é montado como /código no recipiente. Isso significa que se você mudar alguma coisa no Simple_app/content/código, Será refletido em /código pasta no contêiner da web.

Para o serviço Redis:

• Usa a imagem Redis: Alpine do Docker Hub para criar o serviço Redis.

Etapa 5: Executando aplicativos usando o Docker Compose

O aplicativo está pronto para implantação. De Simple_app Pasta, execute o seguinte comando:

$ docker-compor up

A saída deve começar assim:

$ docker-compor up

Building web

Etapa 1/5: De Python: 3.6.3-Jessie

3.6.3-Jessie: puxando da biblioteca/python

85B1F47FBA49: Download [===========>] 12.43MB/52.6 MB

5409E9A7FA9E: Download completo

661393707836: Download [===============>] 13 13.71MB/43.23 MB

1BB98C08D57E: Download [>] 1.081MB/134.7 MB

..

Depois que todas as imagens forem construídas e em execução, você deve ver o seguinte:

STATUS: Imagem mais recente do download para redis: Alpine

Criando SimpleApp_redis_1…

Criando SimpleApp_Web_1…

Criando SimpleApp_redis_1

Criando SimpleApp_Web_1… feito

Anexando -se a SimpleApp_redis_1, SimpleApp_Web_1

Redis_1 | 1: m 21 out 02:06:33.639 * Pronto para aceitar conexões

Web_1 | * Executando em http: // 0.0.0.0: 5000/ (pressione Ctrl+C para sair)

Web_1 | * Reiniciando com Stat

Web_1 | * Debugger está ativo!

Web_1 | * Pino do depurador: 237-189-083

Você pode testar o aplicativo indo para http: // localhost: 5000:. Se você atualizar a página algumas vezes, ela deve refletir o número de visitas. Você pode verificar o status dos serviços ou contêineres em execução:

$ docker ps

Comando de imagem de identificação de contêiner nomes de portas de status criados

22852E0AD98A Redis: Alpine "Docker-EntryPoint…" 5 minutos atrás 5 minutos 6379/TCP SimpleApp_redis_1

D51739D0A3AC SimpleApp_Web "Python Simple_App.py "5 minutos atrás 5 minutos 0.0.0.0: 5000-> 5000/TCP SimpleApp_Web_1

Se você iniciar um shell Bash em SimpleApp_Web_1 (o nome do seu contêiner pode diferir), você estará conectado ao diretório /código de trabalho:

$ Docker Exec -it SimpleApp_Web_1 Bash

root@d51739d0a3ac:/code# ls

requisitos.txt simples_app.py

root@d51739d0a3ac:/código#

O /código diretório deve refletir o conteúdo de Simple_app/content/código dentro dele, como visto acima (Simple_app.py e requisitos.TXT).

Se você atualizar seu Simple_app.pyLinha de:

retornar 'Bem -vindo ao Docker compor lições! Você visitou este site tempos.\ n '.formato (contagem)

Para:

retornar 'Bem -vindo ao Docker compor lições! Você está intrigado? Você visitou este site tempos.\ n '.formato (contagem)

Deve refletir sobre http: // localhost: 5000:

Etapa 6: desligando os serviços

Você pode interromper o aplicativo usando:

$ Docker-Compose Stop

Parando simleApp_redis_1… feito

Parando simplyApp_web_1… feito

Os volumes montados persistirão. Você pode remover totalmente os contêineres, incluindo os volumes usando o seguinte comando.

$ docker-compose para baixo-volume

Removendo SimpleApp_redis_1… feito

Removendo SimpleApp_Web_1… feito

Removendo a rede SimpleApp_default

Parabéns! Você dominou o básico do Docker Compose.

Um estudo mais aprofundado

Para estudos adicionais, consulte a seguinte documentação:

• Documentação do Docker
• Docker Compose Reference
• Docker compor networking

Referências:

• https: // docs.Docker.com/compõe/visão geral/#Desenvolvimento-ambiente
• https: // docs.Docker.com/compor/fingebingted/
• https: // blog.Faça pela moda.com/orquestrate-containers-for-Development-With-Docker-Comppose/
• https: // www.Sumológico.com/blog/devOps/como-to-build-applications-docker-compose/
• https: // docs.Docker.com/compuse/wordpress/#define o projeto