Manter aplicações atualizadas é crucial para garantir segurança, performance e a incorporação de novas funcionalidades. No mundo dos containers Docker, WatchTower surge como uma ferramenta poderosa para automatizar esse processo. Neste artigo, vamos explorar como integrar o WatchTower com o GitHub Container Registry (GHCR), criando um fluxo contínuo de atualização para seus containers. Vamos abordar desde a configuração inicial até um exemplo prático para ilustrar todo o processo.

🚀 Introdução ao WatchTower e GHCR

O que é o WatchTower?

WatchTower é uma ferramenta de código aberto que monitora seus containers Docker e automaticamente os atualiza quando uma nova imagem é detectada no registry configurado. Isso elimina a necessidade de intervenções manuais para manter suas aplicações sempre atualizadas com as últimas versões.

O que é o GitHub Container Registry (GHCR)?

O GitHub Container Registry é um serviço de registro de containers integrado ao GitHub, permitindo que você armazene e gerencie suas imagens Docker diretamente nos repositórios do GitHub. Ele oferece integração perfeita com workflows de CI/CD, facilitando a publicação e o gerenciamento de imagens.

🛠️ Pré-requisitos

Antes de começarmos, certifique-se de ter o seguinte:

• Docker instalado na sua máquina ou servidor.
• Conta no GitHub com acesso ao GitHub Container Registry.
• Repositório GitHub para hospedar sua aplicação e workflow.
• Conhecimentos básicos de Docker e GitHub Actions.

🔧 Passo a Passo: Integrando WatchTower com GHCR

1. Configurando o GitHub Container Registry

Primeiro, vamos configurar o GHCR para armazenar nossas imagens Docker.

a. Autenticação no GHCR

Para autenticar o Docker com o GHCR, você precisa de um token de acesso pessoal com permissão para write:packages e read:packages.

echo $CR_PAT | docker login ghcr.io -u USERNAME --password-stdin

Substitua CR_PAT pelo seu token de acesso pessoal e USERNAME pelo seu nome de usuário do GitHub.

b. Criando uma Imagem Docker

Vamos criar uma imagem Docker simples para este exemplo. Crie um arquivo Dockerfile:

# Dockerfile
FROM node:14-alpine
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

E um arquivo package.json básico:

{
  "name": "watchtower-example",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "express": "^4.17.1"
  }
}

Crie também um index.js simples:

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello from WatchTower and GHCR!');
});

app.listen(port, () => {
  console.log(`App running on port ${port}`);
});

c. Construindo e Publicando a Imagem

Construa a imagem Docker e publique-a no GHCR.

docker build -t ghcr.io/USERNAME/watchtower-example:latest .
docker push ghcr.io/USERNAME/watchtower-example:latest

Substitua USERNAME pelo seu nome de usuário do GitHub.

1. Configurando o WatchTower

Agora, vamos configurar o WatchTower para monitorar o GHCR e atualizar automaticamente nossos containers.

a. Criando um Arquivo de Configuração do WatchTower

Crie um arquivo docker-compose.yml para orquestrar o WatchTower e sua aplicação.

version: '3'

services:
  app:
    image: ghcr.io/USERNAME/watchtower-example:latest
    container_name: watchtower-example
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production

  watchtower:
    image: containrrr/watchtower
    container_name: watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - WATCHTOWER_CLEANUP=true
      - WATCHTOWER_POLL_INTERVAL=300
    command: --registry ghcr.io --interval 300

Explicações:

• app: Serviço da aplicação que será monitorada pelo WatchTower.
• watchtower: Serviço do WatchTower configurado para monitorar o GHCR com um intervalo de verificação de 5 minutos (300 segundos).

b. Variáveis de Ambiente para Autenticação

Para que o WatchTower possa acessar o GHCR privado, precisamos fornecer as credenciais. Atualize o serviço watchtower no docker-compose.yml:

environment:
  - WATCHTOWER_CLEANUP=true
  - WATCHTOWER_POLL_INTERVAL=300
  - WATCHTOWER_REGISTRY_AUTH=true
  - WATCHTOWER_REGISTRY_USERNAME=USERNAME
  - WATCHTOWER_REGISTRY_PASSWORD=CR_PAT

Substitua USERNAME pelo seu nome de usuário do GitHub e CR_PAT pelo seu token de acesso pessoal.

1. Automatizando a Atualização com GitHub Actions

Para garantir que sempre que você fizer push no repositório, a imagem Docker seja atualizada no GHCR, vamos configurar um workflow no GitHub Actions.

Crie um arquivo .github/workflows/docker-publish.yml no seu repositório:

name: Publish Docker image

on:
  push:
    branches: [ main ]

jobs:
  build-and-push:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

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

      - name: Login to GHCR
        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Build and push
        uses: docker/build-push-action@v4
        with:
          context: .
          push: true
          tags: ghcr.io/USERNAME/watchtower-example:latest

Explicações:

• actions/checkout@v3: Faz o checkout do código.
• docker/setup-buildx-action@v3: Configura o Docker Buildx.
• docker/login-action@v3: Autentica no GHCR usando o token do GitHub.
• docker/build-push-action@v4: Constrói e publica a imagem no GHCR.

Substitua USERNAME pelo seu nome de usuário do GitHub.

1. Implementando e Testando

a. Deploy Inicial

Inicie os serviços usando o Docker Compose:

docker-compose up -d

Isso iniciará sua aplicação e o WatchTower. O WatchTower começará a monitorar o GHCR a cada 5 minutos (300 segundos) para verificar se há novas imagens disponíveis.

b. Atualizando a Aplicação

Faça uma alteração no código da sua aplicação, por exemplo, atualize a mensagem em index.js:

res.send('Hello from WatchTower, GHCR, and your updated app!');

Commit e push as alterações para o repositório GitHub:

git add .
git commit -m "Update welcome message"
git push origin main

O GitHub Actions irá construir e publicar a nova imagem no GHCR. Após até 5 minutos, o WatchTower detectará a nova imagem e atualizará automaticamente o container watchtower-example sem downtime.

🎉 Conclusão

Integrar o WatchTower com o GitHub Container Registry oferece uma solução eficiente para manter suas aplicações Docker sempre atualizadas de forma automática. Essa automação não apenas economiza tempo, mas também garante que suas aplicações estejam sempre rodando as versões mais recentes e seguras. Além disso, combinando com ferramentas como o Traefik, você pode criar uma infraestrutura robusta e escalável, pronta para atender às demandas de ambientes de produção modernos.

Experimente implementar essa integração no seu projeto e aproveite os benefícios da automação contínua!

📚 Recursos Adicionais

• WatchTower GitHub Repository
• GitHub Container Registry Documentation
• Docker Compose Documentation
• GitHub Actions Documentation