Este capítulo aborda novos comandos do Docker e detalhes sobre como compartilhar dados entre o sistema host e aplicações conteinerizadas. Aprenda quando e como usar volumes persistentes e acessar sistemas de arquivos do host.

Comandos intermediários do Docker

Ajuda de relance

Contêineres existentes

Limpeza automática de contêiner

Montando o sistema de arquivos do host

Passando um arquivo para um contêiner em execução

Sumiu, mas não foi esquecido

Métodos diferentes, mesmo resultado

Volumes persistentes

Criando um volume de contêiner

Contêineres diferentes, mesmo volume

Comandos e sistemas de arquivos

Aprenda a expor serviços de rede no Docker, criar redes Docker e usar Dockerfiles para manter configurações de rede.

Revisão de redes

Qual é o meu IP?

Portas válidas

Disponibilizando serviços de rede no Docker

Mapeando uma porta

Vários containers, mesma porta do host?

Expondo portas com Dockerfiles

Tantas opções

Mapeando uma porta do contêiner

Usando mapeamento efêmero

Redes Docker

Criando uma rede Docker

Adicionando contêineres a uma rede

Intervalos de IP

Removendo redes de contêineres

Rede

Aprenda a usar as ferramentas avançadas de gerenciamento e build de imagens do Docker para criar imagens de contêiner compactas e eficazes. Crie imagens multiplataforma capazes de rodar em diferentes arquiteturas de processador.

Otimizando imagens Docker

Controle suas preocupações

Exploração de imagens Docker

Determinando a melhor imagem para usar

Entendendo camadas

Bolo de camadas

Quantas camadas?

Builds multiestágio

Build de estágio único

Build multiestágio

Entendendo builds multi-stage

Compilações multiplataforma

Etapas multiplataforma

Build multi-plataforma

Criando imagens avançadas de contêiner

Combine os recursos de volumes, rede e manipulação de contêineres do Docker em aplicativos multiconteiner usando Docker Compose. Atualize e gerencie implantações de aplicativos por meio do arquivo docker-compose.yml.

Introdução ao Docker Compose

Gerenciando um aplicativo com Docker Compose

Solucionando problemas na inicialização da aplicação

Criando arquivos compose.yaml

Escrevendo um arquivo compose.yaml

Identificando seções

Quantos recursos?

Dependências e solução de problemas no Docker Compose

Ordem de inicialização dos recursos

Cálculo de dependências

Ordem de desligamento

FROM python:3.12-alpine3.19
WORKDIR /code
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["python3", "app.py"]


import time
import redis

cache = redis.Redis(host='redis', port=6379, socket_timeout=1)

def get_hit_count():
  retries = 5
  while True:
    try:
      return cache.incr('hits')
    except redis.exceptions.ConnectionError as exc:
      if retries == 0:
        raise exc
      retries -= 1
      time.sleep(0.5)

def hello():
  count = get_hit_count()
  return f'Successfully communicated {count} times.\n'

for i in range(0, 5):
  print(f"{hello()}")


services:
  app:
    build: .
  redis:
    image: "redis:alpine3.20"
    depends_on:
      - app


services:
  app:
    build: .
    depends_on:
      - redis
  redis:
    image: "redis:alpine3.20"


# Solution Steps:
  # 1. Run `docker compose up -d` to start the services
  # 2. Use `docker compose logs` to view the startup logs and identify errors
  # 3. Examine the compose.yaml file to find the dependency issue
  # 4. Update the compose.yaml to move depends_on from redis to app service
  # 5. Run `docker compose down` to stop all services
  # 6. Rerun `docker compose up -d` and verify you see "Successfully communicated" messages

Solucionando problemas de dependências

Criando um serviço de dados dentro do Docker

import duckdb
from flask import Flask

app = Flask(__name__)

@app.route("/tripcount")
def returndata():
  cursor = duckdb.connect()
  try:
    count = cursor.execute("select count(*) from read_parquet('/data/*.parquet')").fetchall()[0][0]
    return f"Total trips: {count}"
  except duckdb.duckdb.IOException:
    return f"Data files are not present", 503

@app.route("/first")
def returnfirst():
  cursor = duckdb.connect()
  try:
    first = cursor.execute("select min(tpep_pickup_datetime) from read_parquet('/data/*.parquet')").fetchall()[0][0]
    return f"First pickup: {first:%Y/%m/%d}" 
  except duckdb.duckdb.IOException:
    return f"Data files are not present", 503

@app.route("/last")
def returnlast():
  cursor = duckdb.connect()
  try:
    last = cursor.execute("select max(tpep_pickup_datetime) from read_parquet('/data/*.parquet')").fetchall()[0][0]
    return f"Last pickup: {last:%Y/%m/%d}" 
  except duckdb.duckdb.IOException:
    return f"Data files are not present", 503


FROM python:3.12-alpine3.19

#
# NOTE: Application reads contents of /data in container
# If not found, application returns errors.
# 

WORKDIR /app
ENV FLASK_RUN_HOST=0.0.0.0

COPY code/app.py .
COPY code/requirements.txt .

RUN pip install -r requirements.txt --root-user-action=ignore

EXPOSE 5000

CMD ["flask", "run"]


STATUS_CODE=$(curl --silent --head http://localhost:5000/tripcount | awk '/^HTTP/{print $2}')

if [ "$STATUS_CODE" == "503" ]; then
  echo "ERROR ACCESSING DATA SERVICE - PLEASE VERIFY DATA IS PRESENT"
  echo "Did you use a -v flag with your docker run command?"
elif [ "$STATUS_CODE" == "200" ]; then
  echo "SUCCESSFULLY ACCESSED DATA SERVICE!"
else
  echo "ERROR ACCESSING DATA SERVICE - PLEASE VERIFY SERVICE IS RUNNING"
  echo "Did you start your container with a -p flag?"
fi
  


There are several steps required to complete this exercise:

- Build the dataservice container using the following command in the terminal:

docker build . -t dataservice

- Run an instance of the Docker container as follows:

docker run -d -p5000:5000 -v ~/workspace/datasets:/data dataservice

- Verify that the service is working by running the ./app_test.sh on the terminal


Criando um backend de serviço de dados

Adicionando um cliente de dados

services:
  ____:
    image: dataservice
    volumes:
      - /home/repl/datasets:/data
    networks: 
      data_net:
        ipv4_address: 10.11.12.2

  dataclient:
    image: ____
    depends_on: 
      - ____
    networks:
      data_net:
        ipv4_address: 10.11.12.3

# Ignore everything below this line
networks:
  data_net:
    driver: macvlan
    ipam:
      config:
        - subnet: "10.11.12.0/24"
    


services:
  dataservice:
    image: dataservice
    volumes:
      - /home/repl/workspace/datasets:/data
    networks: 
      data_net:
        ipv4_address: 10.11.12.2

  dataclient:
    image: dataclient
    depends_on: 
      - dataservice
    networks:
      data_net:
        ipv4_address: 10.11.12.3

# Ignore everything below this line
networks:
  data_net:
    driver: macvlan
    ipam:
      config:
        - subnet: "10.11.12.0/24"
    


- Update the compose.yaml file as shown.
- Run the following command:

  docker compose up -d
  
- Run the command:

  docker compose logs dataclient


Usando o Docker Compose para definir um aplicativo completo

Parabéns!

Docker Compose

Este curso aprofunda as bases de Docker e conteinerização apresentadas no curso Introduction to Docker. Vamos expandir os conceitos e ferramentas daquele curso, adicionando ideias de gerenciamento e otimização de imagens de contêiner, rede, comunicação por sistema de arquivos e aplicativos multiplataforma e multiconteiner. Ao concluir, você será capaz de:

- Criar builds multi-stage para otimizar o tamanho, a segurança e a reutilização de aplicações conteinerizadas.
- Usar ferramentas e conceitos de rede do Docker para adicionar comunicação entre contêineres e oferecer serviços de rede à rede local e ao mundo externo.
- Compartilhar arquivos e dados entre contêineres e a máquina host usando mounts e volumes do sistema de arquivos do Docker.
- Criar implantações de aplicativos multiconteiner usando Docker Compose, simplificando drasticamente a configuração de ferramentas complexas comuns em ciência e engenharia de dados.

Você aproveitará melhor este curso se já tiver trabalhado e criado alguns contêineres simples, mas quer ampliar seu conjunto de ferramentas de desenvolvimento, teste e distribuição. Estamos ansiosos para orientar você na sua jornada de aprendizado de Docker.

Esse curso vai além do que você aprendeu no curso Introdução ao Docker, falando mais sobre os conceitos e ferramentas de conteinerização. Vamos explorar assuntos mais avançados, como gerenciamento de imagens de contêineres, redes, comunicação de sistemas de arquivos e desenvolvimento de aplicativos multiplataforma e multicontêineres.
<h2>Otimizando aplicativos em contêineres</h2>
Aprenda a criar compilações em várias etapas para melhorar o tamanho, a segurança e a reutilização de aplicativos em contêineres. Através de exercícios práticos, domine técnicas para otimizar imagens de contêineres, garantindo uma implantação e gerenciamento eficientes em diversos ambientes.
<h2>Melhorando as implantações de contêineres com o Docker Compose</h2>
Descubra como usar as ferramentas e os conceitos de rede do Docker para facilitar a comunicação entre contêineres e oferecer serviços de rede para redes locais e externas. Explore as montagens e volumes do sistema de arquivos para compartilhar dados facilmente entre os contêineres e a máquina host. Além disso, aprenda a usar o Docker Compose para organizar implantações de aplicativos com vários contêineres, simplificando a configuração de ferramentas complexas comuns em ambientes de ciência de dados e engenharia.
<h2>Desenvolvimento e implantação proativos</h2>
Este curso te dá as habilidades essenciais para melhorar seus processos de desenvolvimento, teste e distribuição. Embora não seja essencial, você aproveitará melhor este curso se já tiver trabalhado com e criado alguns contêineres simples. Ao final do curso, você vai ter o conhecimento e as ferramentas necessárias para otimizar aplicativos em contêineres, simplificar a comunicação entre contêineres e implantar aplicativos com vários contêineres com facilidade, capacitando você em sua jornada de aprendizado do Docker.

Introduction to Docker

Domine multi-stage builds, ferramentas de rede Docker e Docker Compose para apps otimizados!

Docker Intermediário

Domine compilações em várias etapas, ferramentas de rede Docker e Docker Compose para otimizar aplicativos em contêineres!

Parabéns!

Create Your Free Account