0Pricing
DevOps Bootcamp · Aula

Criação de imagens Docker com Actions

Automatize o processo de criação de imagens Docker para suas aplicações diretamente nos fluxos de trabalho do GitHub Actions.

Criação de imagens Docker com Actions é uma aula grátis de DevOps Bootcamp no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de DevOps Bootcamp, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de DevOps Bootcamp inclui 4 aulas no total.

O que são imagens do Docker?

Boas-vindas! Nesta lição, aprenderemos a criar imagens do Docker usando as Ações do GitHub.

Primeiro, o que é uma imagem do Docker? Pense nela como um pacote leve, independente e executável que inclui tudo o que é necessário para executar uma parte de um software:

  • Seu código
  • Um ambiente de execução (por exemplo, Java, Python)
  • Ferramentas e bibliotecas do sistema
  • Arquivos de configuração

É como um modelo para criar contêineres do Docker, garantindo que seu aplicativo seja executado de forma consistente em diferentes ambientes.

Por que automatizar as compilações do Docker?

Compilar imagens do Docker manualmente pode ser repetitivo e propenso a erros. É nesse ponto que a automação é útil!

Ao integrar a compilação de imagens do Docker ao seu fluxo de CI/CD com as Ações do GitHub, você obtém:

  • Consistência: Cada compilação segue as mesmas etapas.
  • Velocidade: As compilações automatizadas são mais rápidas que as manuais.
  • Confiabilidade: Reduza os erros humanos.
  • Integração: As compilações são acionadas automaticamente quando o código muda.

Essa é uma prática fundamental no DevOps moderno!

O modelo do Dockerfile

Um Dockerfile é um arquivo de texto que contém todos os comandos para montar uma imagem do Docker. É como uma receita.

Aqui está um exemplo de Dockerfile muito simples:

FROM alpine:latest
WORKDIR /app
COPY . .
CMD ["echo", "Hello from Docker!"]

Entendendo o Dockerfile

Vamos detalhar esse Dockerfile simples:

  • FROM alpine:latest: Isso especifica a imagem base. Estamos começando com uma pequena distribuição Linux chamada Alpine.
  • WORKDIR /app: Define o diretório de trabalho dentro da imagem.
  • COPY . .: Copia todos os arquivos do diretório do seu projeto para o diretório /app dentro da imagem.
  • CMD ["echo", "Hello from Docker!"]: Este é o comando que será executado quando um contêiner for iniciado a partir dessa imagem.

Esse arquivo fica na raiz do seu projeto.

Configurando seu fluxo de trabalho

Para criar imagens do Docker com as Ações do GitHub, você criará um arquivo YAML (por exemplo, .github/workflows/docker-build.yml) no seu repositório.

Esse arquivo define seu fluxo de trabalho, que é uma série de etapas automatizadas.

Um fluxo de trabalho básico para criar uma imagem geralmente envolve:

  1. Obter seu código.
  2. Configurar o ambiente de compilação do Docker.
  3. Compilar a imagem do Docker.

Etapa 1: obtenha seu código

A primeira etapa de praticamente qualquer fluxo de trabalho das Ações do GitHub é obter o código do seu repositório. Isso é feito usando a ação actions/checkout.

Ela clona seu repositório no executor, tornando seu Dockerfile e o código do aplicativo disponíveis para o processo de compilação.

Veja como isso aparece no arquivo do seu fluxo de trabalho:

      - name: Checkout repository code
        uses: actions/checkout@v4

Etapa 2: configure o Docker Buildx

Em seguida, precisamos configurar o ambiente de compilação do Docker. A ação docker/setup-buildx-action é altamente recomendada.

O Buildx é um componente do Docker que amplia os recursos de compilação do Docker, oferecendo suporte a recursos avançados, como compilações para várias plataformas.

Adicione esta etapa ao seu fluxo de trabalho:

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

Etapa 3: compile a imagem do Docker

Agora, o ponto principal: compilar a imagem! Para isso, usamos a ação docker/build-push-action.

Opções principais:

  • context: .: Especifica o contexto da compilação (geralmente a raiz do seu repositório).
  • push: false: Por enquanto, vamos apenas compilar sem enviar para um registro. Abordaremos o envio em uma lição posterior.
  • tags: my-app:latest: Atribui um nome e uma etiqueta à sua imagem.
      - name: Build and tag Docker image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: false
          tags: my-app:latest

Exemplo completo de fluxo de compilação

Aqui está o fluxo de trabalho completo das Ações do GitHub para compilar uma imagem do Docker. Lembre-se de que este YAML deve ser colocado em .github/workflows/docker-build.yml.

Esse fluxo de trabalho será acionado a cada push para o seu repositório.

name: Build Simple Docker Image

on: [push]

jobs:
  build-image:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository code
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Build and tag Docker image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: false
          tags: my-app:latest

Verificação rápida

Vamos testar sua compreensão sobre a criação de imagens do Docker com as Ações do GitHub.

Recapitulação: compilação de imagens do Docker

Muito bem! Você aprendeu os fundamentos da automação de compilações de imagens do Docker com as Ações do GitHub.

Vimos:

  • O que são imagens do Docker e por que são essenciais.
  • A função de um Dockerfile como modelo da imagem.
  • Como configurar um fluxo de trabalho básico das Ações do GitHub.
  • Como usar ações essenciais, como actions/checkout, docker/setup-buildx-action e docker/build-push-action.

Na próxima lição, veremos como enviar essas imagens compiladas para um registro de contêineres!

Perguntas Frequentes

A aula “Criação de imagens Docker com Actions” é grátis?

Sim — o texto completo de “Criação de imagens Docker com Actions” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de DevOps Bootcamp, atualize para CoddyKit PRO. O curso de DevOps Bootcamp inclui 4 aulas no total.

O que vou aprender em “Criação de imagens Docker com Actions”?

Automatize o processo de criação de imagens Docker para suas aplicações diretamente nos fluxos de trabalho do GitHub Actions. Você pratica DevOps Bootcamp com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar DevOps Bootcamp?

Nenhuma experiência prévia é necessária. DevOps Bootcamp no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Criação de imagens Docker com Actions”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de DevOps Bootcamp?

Sim. Cada aula de DevOps Bootcamp inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Criação de imagens Docker com Actions
  2. Envio de imagens para registros
  3. Implantação no Kubernetes com Actions
  4. Gráficos Helm e manifestos do Kubernetes em CI/CD
← Voltar para DevOps Bootcamp