This chapter covers new Docker commands and details on how to share data between host system and containerized applications. Learn when and how to use persistent volumes and access host filesystems.

Intermediate Docker Commands

Help at a glance

Existing containers

Automatic container cleanup

Mounting the host filesystem

Passing a file to a running container

Gone, but not forgotten

Different methods, same result

Persistent volumes

Creating a container volume

Different containers, same volume

Commands and filesystems

Learn to expose networking services in Docker, create Docker networks, and use Dockerfiles to maintain network settings.

Networking refresher

What's my IP?

Valid ports

Making network services available in Docker

Mapping a port

Multiple containers, same host port?

Exposing ports with Dockerfiles

So many options

Mapping a container port

Using ephemeral mapping

Docker networks

Creating a docker network

Adding containers to a network

IP Ranges

Removing container networks

Networking

Learn to use Docker's advanced image management and build tools to create compact effective container images. Create multi-platform images capable of running on different processor architectures.

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

package main
import "fmt"

func main() {
  fmt.Println("Application running...")
}


FROM golang:1.21-alpine3.19
WORKDIR /src
COPY /src/main.go /src/main.go

# Build the go application from source code
RUN go build -o /bin/app_runner /src/main.go

CMD ["/bin/app_runner"]


Run the following commands:
  - docker build . -t single-stage-app
  - docker run single-stage-app
  - docker images
Check the size of the single-stage-app image


Build de estágio único

FROM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY /src/main.go /src/main.go

# Build the go application from source code
RUN go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM ____

# Update with name of previous build stage
COPY --from=____ /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


FROM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY src/main.go /src/main.go

# Build the go application from source code
RUN go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM scratch

# Update with name of previous build stage
COPY --from=gobuild /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


Update the Dockerfile as shown in the example.

Once complete, run the following commands in the terminal:

- docker build . -t multi-stage-app
- docker run multi-stage-app
- docker images

Check the size of the single-stage-app and multi-stage-app
containers.


Build multiestágio

Etapas de build do mecanismo Docker

Entendendo builds multi-stage

Compilações multiplataforma

Ordem do build multiplataforma

Etapas multiplataforma

#!/bin/bash

# Note this is an example of string concatenation in jq
#
# There is not a Platform attribute returned by docker image inspect
# so we create our own. This is simply a string returned as Platform,
# consisting of the .Os attribute and the .Architecture attribute joined
# with a slash to produce the Platform field.
#
# This is outside the realm of the course, but is hopefully a further
# example of the power available within the jq tool.

docker image inspect multi-platform-app | jq '.[0] | {Platform: (.Os + "/" + .Architecture)}'


# Update the FROM line to support a multi-platform build
FROM ____=$BUILDPLATFORM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY src/main.go /src/main.go

# Define the option to pull environment variables from the host
____ TARGETOS TARGETARCH

# Build the go application from source code
RUN env GOOS=$TARGETOS GOARCH=$TARGETARCH go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM ____

# Update with name of previous build stage
COPY --from=____ /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


# Update the FROM line to support a multi-platform build
FROM --platform=$BUILDPLATFORM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY src/main.go /src/main.go

# Define the option to pull environment variables from the host
ARG TARGETOS TARGETARCH

# Build the go application from source code
RUN env GOOS=$TARGETOS GOARCH=$TARGETARCH go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM scratch

# Update with name of previous build stage
COPY --from=gobuild /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


Update the Dockerfile as shown in the example.

Once complete, run the following command in the terminal:

- docker buildx build --platform linux/arm64 . -t multi-platform-app 

Verify the platform image built as expected by running the command:

./check_platform.sh

in the terminal window and verify that it returns "linux/arm64"


Build multi-plataforma

Building advanced container images

Combine the the volume, networking, and container handling capabilities of Docker into multi-container applications using Docker Compose. Update and manage application deployments via the docker-compose.yml file.

Introduction to Docker Compose

Managing an application with Docker Compose

Troubleshooting application startup

Creating compose.yaml files

Writing a compose.yaml file

Identifying sections

How many resources?

Dependencies and troubleshooting in Docker Compose

Dependency calculation

Shutdown order

Troubleshooting dependencies

Creating a data service within Docker

Building a data service backend

Adding a data client

Using Docker Compose to define a full application

Congratulations!

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!

Build de estágio único

Docker Intermediário

exercicio interativo prático