This content originally appeared on DEV Community and was authored by Lucas Aguiar
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
- 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.
- 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.
- 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.
- 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
This content originally appeared on DEV Community and was authored by Lucas Aguiar
Lucas Aguiar | Sciencx (2024-10-08T17:05:55+00:00) Automatizando Atualizações de Containers com WatchTower e GitHub Container Registry. Retrieved from https://www.scien.cx/2024/10/08/automatizando-atualizacoes-de-containers-com-watchtower-e-github-container-registry/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.