Guia de iniciação do Docker Compose

O autor do artigo, cuja tradução estamos publicando hoje, diz que ele é destinado aos desenvolvedores que desejam aprender o Docker Compose e criarão seu primeiro aplicativo cliente-servidor usando o Docker. O leitor deve estar familiarizado com o básico do Docker. Se não for esse o caso, você pode dar uma olhada nesta série de materiais, nesta publicação, onde os conceitos básicos do Docker são discutidos juntamente com os conceitos básicos do Kubernetes e este artigo para iniciantes.

O que é o Docker Compose?

O Docker Compose é uma ferramenta incluída no Docker. Ele foi projetado para resolver os problemas associados à implantação de projetos.

Estudando o básico do Docker, você pode ter encontrado a criação de aplicativos simples que funcionam de forma autônoma, independentemente de, por exemplo, fontes de dados externas ou determinados serviços. Na prática, essas aplicações são raras. Projetos reais geralmente incluem todo um conjunto de aplicativos colaborativos.

Como você sabe se precisa usar o Docker Compose ao implantar um projeto? De fato - muito simples. Se vários serviços forem usados ​​para garantir o funcionamento deste projeto, o Docker Compose poderá ser útil. Por exemplo, em uma situação em que eles criam um site que, para autenticar usuários, precisa se conectar ao banco de dados. Um projeto semelhante pode consistir em dois serviços - um que fornece o site e outro responsável pela manutenção do banco de dados.

A tecnologia Docker Compose, se descrita de forma simplista, permite, com um único comando, iniciar muitos serviços.

Diferença entre o Docker e o Docker Compose

O Docker é usado para gerenciar os contêineres (serviços) individuais que compõem o aplicativo.

O Docker Compose é usado para gerenciar simultaneamente vários contêineres que compõem o aplicativo. Essa ferramenta oferece os mesmos recursos do Docker, mas permite trabalhar com aplicativos mais complexos.


Docker (contêiner único) e Docker Compose (vários contêineres)

Caso de uso típico do Docker Compose

O Docker Compose é, na mão direita, uma ferramenta muito poderosa que permite implantar rapidamente aplicativos com uma arquitetura complexa. Agora, veremos um exemplo do uso prático do Docker Compose, cuja análise permitirá avaliar as vantagens que você terá ao usar o Docker Compose.

Imagine que você é um desenvolvedor de um projeto da web. Este projeto inclui dois sites. O primeiro permite que as pessoas nos negócios criem, com apenas alguns cliques, lojas online. O segundo é voltado para o suporte ao cliente. Esses dois sites interagem com o mesmo banco de dados.

Seu projeto está se tornando mais popular e acontece que o poder do servidor no qual ele trabalha não é mais suficiente. Como resultado, você decide transferir o projeto inteiro para outra máquina.

Infelizmente, você não usou algo como o Docker Compose. Portanto, você terá que transferir e reconfigurar os serviços, um de cada vez, esperando que, no processo deste trabalho, não esqueça nada.

Se você usa o Docker Compose, a transferência do seu projeto para um novo servidor é uma questão que pode ser resolvida executando vários comandos. Para concluir a transferência do projeto para um novo local, você só precisa executar algumas configurações e fazer upload de uma cópia de backup do banco de dados no novo servidor.

Desenvolvendo um aplicativo cliente-servidor usando o Docker Compose

Agora que você sabe para o que usaremos o Docker Compose, é hora de criar seu primeiro aplicativo cliente-servidor usando essa ferramenta. Ou seja, estamos falando sobre o desenvolvimento de um pequeno site (servidor) em Python, que pode produzir um arquivo com um fragmento de texto. Este arquivo é solicitado ao servidor por um programa (cliente), também escrito em Python. Após receber o arquivo do servidor, o programa exibe o texto armazenado na tela.

Observe que esperamos que você seja o proprietário do básico do Docker e que você já tenha a plataforma Docker instalada.

Vamos trabalhar no projeto.

▍1 Criação de projeto

Para criar seu primeiro aplicativo cliente-servidor, sugiro começar com a criação de uma pasta do projeto. Ele deve conter os seguintes arquivos e pastas:

• docker-compose.yml . Este é um arquivo do Docker Compose que conterá as instruções necessárias para iniciar e configurar serviços.
• Pasta do server . Ele conterá os arquivos necessários para garantir a operação do servidor.
• client pasta. Aqui estão os arquivos do aplicativo cliente.

Como resultado, o conteúdo da pasta principal do seu projeto deve ficar assim:

 . ├── client/ ├── docker-compose.yml └── server/ 2 directories, 1 file 

§ 2 Criação de servidor

Aqui, no processo de criação do servidor, abordaremos algumas coisas básicas sobre o Docker.

2a Criação de arquivo

Vá para a pasta do server e crie os seguintes arquivos nela:

• Arquivo server.py . Ele conterá o código do servidor.
• Arquivo index.html . Este arquivo conterá um pedaço de texto que o aplicativo cliente deve exibir.
• Arquivo Dockerfile . Este é um arquivo do Docker que conterá as instruções necessárias para criar um ambiente de servidor.

É assim que deve ser o conteúdo do seu server/ pasta:

 . ├── Dockerfile ├── index.html └── server.py 0 directories, 3 files 

2b. Editando um arquivo Python.

Adicione o seguinte código ao arquivo server.py :

 #!/usr/bin/env python3 #    python. #       -. #     - ,      Python. import http.server import socketserver #         . handler = http.server.SimpleHTTPRequestHandler #   ,        1234. #    ,        ,    docker-compose. with socketserver.TCPServer(("", 1234), handler) as httpd:   #       ,    .  httpd.serve_forever() 

Este código permite criar um servidor web simples. Ele fornecerá aos clientes o arquivo index.html , cujo conteúdo será exibido posteriormente na página da web.

2c. Edição de arquivo HTML

Adicione o seguinte texto ao arquivo index.html :

 Docker-Compose is magic! 

Este texto será transmitido ao cliente.

2d. Editando o Dockerfile

Agora, criaremos um Dockerfile simples, que será responsável por organizar o tempo de execução do servidor Python. Usaremos a imagem oficial destinada à execução de programas escritos em Python como base da imagem criada. Aqui está o conteúdo do Dockerfile:

 #    ,  Dockerfile       . #      'FROM'. #      python ( DockerHub). #   ,    ,  'python',     - 'latest'. FROM python:latest #       ,   Python,     'server.py'  'index.html'. #     ,     'ADD'. #  , 'server.py',    ,   . #  , '/server/',  ,        . #        '/server/'. ADD server.py /server/ ADD index.html /server/ #     'WORKDIR', ,   . #      . #    ,      ,   '/server/'. WORKDIR /server/ 

Agora vamos trabalhar no cliente.

▍3 Criação de Clientes

Criando a parte do cliente do nosso projeto, recordaremos simultaneamente alguns dos conceitos básicos do Docker.

3a. Criação de arquivo

Vá para a pasta do seu projeto do client e crie os seguintes arquivos nela:

• O arquivo client.py . Este será o código do cliente.
• Arquivo Dockerfile . Este arquivo desempenha a mesma função que um arquivo semelhante na pasta do servidor. Nomeadamente, contém instruções que descrevem a criação de um ambiente para executar o código do cliente.

Como resultado, seu client/ pasta nesta fase do trabalho deve ficar assim:

 . ├── client.py └── Dockerfile 0 directories, 2 files 

3b Edição de arquivos Python

Adicione o seguinte código ao arquivo client.py :

 #!/usr/bin/env python3 #    Python. #      'index.html'  . #     ,      Python. import urllib.request #      'http://localhost:1234/'. # ,      ,   'http://localhost:1234'. # localhost   ,      . # 1234 -   ,        . fp = urllib.request.urlopen("http://localhost:1234/") # 'encodedContent'     ('index.html'). # 'decodedContent'     (  ,      ). encodedContent = fp.read() decodedContent = encodedContent.decode("utf8") #   ,    ('index.html'). print(decodedContent) #    . fp.close() 

Graças a esse código, o aplicativo cliente pode baixar dados do servidor e exibi-los na tela.

3c. Editando o Dockerfile

Como no caso do servidor, criamos um Dockerfile simples para o cliente, responsável por criar o ambiente em que o aplicativo Python do cliente funcionará. Aqui está o código do Dockerfile do cliente:

 #   ,     Dockerfile. FROM python:latest #  'client.py'   '/client/'. ADD client.py /client/ #      '/client/'. WORKDIR /client/ 

▍4 Docker compor

Como você deve ter notado, criamos dois projetos diferentes: o servidor e o cliente. Cada um deles tem seu próprio Dockerfile . Até agora, tudo o que acontece não vai além do básico de trabalhar com o Docker. Agora estamos começando com o Docker Compose. Para fazer isso, recorremos ao arquivo docker-compose.yml localizado na pasta raiz do projeto.

Observe que aqui não estamos tentando considerar absolutamente todos os comandos que podem ser usados ​​no docker-compose.yml . Nosso principal objetivo é fornecer um exemplo prático que fornece conhecimentos básicos sobre o Docker Compose.

Aqui está o código para colocar no docker-compose.yml :

 #  docker-compose     . #   "3"    -        . version: "3" #  ,  docker-composes   . # 1  = 1 . #    , ,   ... # ,     ,   'services'. services: #    ,       . #  ,     . #   (): . #    ,   . #       . #  ,    ,    'server'. server:   #   "build"     #    Dockerfile,      ,   #    .   #  'server/'     ,   #    Dockerfile.   build: server/   # ,      .   #     "python ./server.py".   command: python ./server.py   #   ,      'server/server.py'   1234.   #          (   ),   #         .   #       'ports'.   #      : [ ]:[ ]   #        1234         # 1234  (         #   ).   ports:     - 1234:1234 #   (): . #    'client'. client:   #  'client/    ,     #  Dockerfile    .   build: client/   # ,      .   #     "python ./client.py".   command: python ./client.py   #   'network_mode'     .   #    ,      'localhost' .   network_mode: host   #   'depends_on'  ,   ,   #   , ,       .   #  ,   'client'       'server'.   depends_on:     - server 

▍5. Montagem do projeto

Depois que todas as instruções necessárias estiverem incluídas no docker-compose.yml , o projeto precisará ser montado. Esta etapa do nosso trabalho se assemelha ao uso do docker build , mas o comando correspondente está relacionado a vários serviços:

 $ docker-compose build 

§ 6 Lançamento do projeto

Agora que o projeto está concluído, é hora de iniciá-lo. Esta etapa do nosso trabalho corresponde à etapa na qual, ao trabalhar com contêineres individuais, o comando docker run é executado:

 $ docker-compose up 

Após executar este comando, o terminal deve exibir o texto baixado pelo cliente no servidor: Docker-Compose is magic! .

Como já mencionado, o servidor usa a porta 1234 do computador para atender às solicitações do cliente. Portanto, se você acessar o navegador em http: // localhost: 1234 / , uma página com o texto Docker-Compose is magic! será exibida nela Docker-Compose is magic! .

Comandos úteis

Vejamos alguns dos comandos que você pode achar úteis ao trabalhar com o Docker Compose.

Este comando permite parar e excluir contêineres e outros recursos criados pelo docker-compose up :

 $ docker-compose down 

Este comando exibe os logs de serviço:

 $ docker-compose logs -f [service name] 

Por exemplo, em nosso projeto, ele pode ser usado da seguinte forma: $ docker-compose logs -f [service name] .

Usando este comando, você pode listar os contêineres:

 $ docker-compose ps 

Este comando permite executar um comando em um contêiner em execução:

 $ docker-compose exec [service name] [command] 

Por exemplo, pode ficar assim: docker-compose exec server ls .

Este comando permite exibir uma lista de imagens:

 $ docker-compose images 

Sumário

Examinamos os conceitos básicos do trabalho com a tecnologia Docker Compose, cujo conhecimento permitirá que você use essa tecnologia e, se desejar, inicie um estudo mais aprofundado. Aqui está o repositório com o código do projeto que analisamos aqui.

Caros leitores! Você usa o Docker Compose em seus projetos?