Introdução à Automação de Deploy em VDS Server com Ansible e Docker
A gestão de infraestrutura moderna exige velocidade, consistência e reprodutibilidade. Para profissionais de TI que operam em ambientes de VDS Server (Virtual Dedicated Server), a combinação de containerização com orquestração de configuração é o padrão ouro para entregas ágeis. Neste tutorial, exploraremos como utilizar o Ansible, uma ferramenta de automação sem agente (agentless), em conjunto com o Docker, para criar pipelines de deploy automatizados.
O objetivo principal é eliminar a intervenção manual na execução de comandos no servidor de destino, reduzindo drasticamente o risco de erros humanos ("drift" de configuração) e acelerando o ciclo de vida do software. Ao final deste guia, você terá uma estrutura pronta para provisionar ambientes Docker em seu VDS, atualizar containers e gerenciar imagens de forma programática.
Pré-requisitos e Arquitetura do Ambiente
Antes de iniciar a implementação técnica, é fundamental entender a arquitetura que será construída. O modelo clássico de automação com Ansible segue uma estrutura cliente-servidor, onde o Control Node (o computador onde você executa os comandos) comunica-se com os Managed Nodes (seus VDS Servers) via SSH.
Para este cenário, definiremos os seguintes componentes:
- Control Node: Sua estação de trabalho local ou um servidor CI/CD dedicado. Ele conterá o código Ansible e as definições de infraestrutura.
- Managed Node: Seu VDS Server rodando Linux (Ubuntu, Debian ou CentOS). Este é o ambiente onde o Docker estará instalado e onde suas aplicações serão executadas.
- Docker: O runtime de containers responsável por isolar as aplicações.
É essencial garantir que o Control Node tenha acesso SSH ao Managed Node sem necessidade de senha (via chaves SSH) para permitir a execução não interativa dos playbooks. Além disso, certifique-se de que o usuário utilizado possua privilégios de sudo ou seja membro do grupo docker no VDS Server.
Passo 1: Preparação do Ambiente Local (Control Node)
A primeira etapa envolve preparar o ambiente onde os scripts de automação residirão. Criaremos uma estrutura de diretórios padrão para projetos Ansible, facilitando a manutenção e escalabilidade futura.
- Crie um diretório raiz para o projeto:
mkdir ansible-docker-deploy
cd ansible-docker-deployDentro desta pasta, criaremos três subdiretórios principais: inventory para definir os servidores alvo, playbooks para as tarefas de automação e roles (opcional para projetos simples, mas recomendado) para modularização. Para este tutorial, manteremos a simplicidade em um único playbook.
- Inicialize o diretório de inventário:
mkdir inventory
touch inventory/hostsO arquivo inventory/hosts funcionará como a lista de endereços IP ou DNS dos seus VDS Servers. Edite este arquivo e adicione o endereço do seu servidor:
[docker_servers]
192.168.1.100 ansible_user=seu_usuario ansible_ssh_private_key_file=~/.ssh/id_rsaSubstitua 192.168.1.100 pelo IP real do seu VDS e seu_usuario pelo nome de usuário com permissões adequadas. A flag ansible_ssh_private_key_file aponta para a chave privada usada para autenticação, garantindo que o Ansible não peça senha durante a execução.
Passo 2: Instalação e Configuração do Ansible
O Ansible pode ser instalado na maioria dos sistemas operacionais via gerenciadores de pacotes ou pip. Para garantir compatibilidade com módulos específicos, instale as coleções necessárias.
- Instale o core do Ansible:
sudo apt update
sudo apt install ansibleEm sistemas baseados em Red Hat ou CentOS:
sudo yum install epel-release
sudo yum install ansible- Instale a coleção oficial do Docker, que contém os módulos para gerenciar imagens, containers e volumes:
ansible-galaxy collection install community.dockerEsta coleção é essencial, pois o módulo padrão de Docker no Ansible está depreciado. A comunidade Docker mantém esta coleção atualizada com as funcionalidades mais recentes da API do Docker.
Passo 3: Desenvolvimento do Playbook de Automação
O coração da automação é o Playbook, um arquivo YAML que descreve o estado desejado da infraestrutura. Criaremos um playbook chamado deploy.yml no diretório raiz. Este script realizará três tarefas principais:
- Instalar o Docker Engine caso não esteja presente.
- Criar uma rede Docker personalizada para comunicação interna segura.
- Buildar e rodar uma imagem de container baseada em um exemplo prático (Nginx).
Crie o arquivo deploy.yml e insira o seguinte conteúdo:
---
- name: Provisionar ambiente Docker no VDS Server
hosts: docker_servers
become: true
gather_facts: yes
tasks:
# Tarefa 1: Instalar dependências do Docker
- name: Install required system packages
apt:
name:
- ca-certificates
- curl
- gnupg
- lsb-release
state: present
update_cache: yes
# Tarefa 2: Adicionar chave GPG oficial do Docker
- name: Add Docker GPG key
apt_key:
url: https://download.docker.com/linux/ubuntu/gpg
state: present
# Tarefa 3: Adicionar repositório estável do Docker
- name: Add Docker repository
apt_repository:
repo: deb [arch=amd64] https://download.docker.com/linux/ubuntu stable
state: present
# Tarefa 4: Instalar o Docker Engine
- name: Install Docker Engine
apt:
name:
- docker-ce
- docker-ce-cli
- containerd.io
- docker-buildx-plugin
- docker-compose-plugin
state: present
# Tarefa 5: Iniciar e habilitar o serviço Docker
- name: Start Docker service
systemd:
name: docker
state: started
enabled: yes
# Tarefa 6: Criar rede Docker personalizada
- name: Create Docker network
community.docker.docker_network:
name: app_network
driver: bridge
ipam_config:
- subnet: '172.20.0.0/16'
# Tarefa 7: Pull e Rodar Container Nginx
- name: Run Nginx container on custom network
community.docker.docker_container:
name: web_app
image: nginx:latest
ports:
- "8080:80"
networks:
- name: app_network
restart_policy: unless-stopped
Analisemos os pontos críticos deste código. A diretiva become: true eleva as permissões para root nas tarefas, necessária para instalar pacotes e gerenciar serviços de sistema. O módulo community.docker.docker_container é o responsável pela orquestração do container. Ao definir restart_policy: unless-stopped, garantimos que o container reinicie automaticamente após falhas ou reinicializações do VDS Server, aumentando a resiliência da infraestrutura.
Passo 4: Executando a Automação
Com o playbook escrito e o inventário configurado, estamos prontos para aplicar a configuração. O Ansible utiliza uma abordagem declarativa: você diz o que quer, e ele calcula como chegar lá.
- Realize um teste de conectividade para verificar se o Ansible consegue acessar o VDS Server:
ansible all -m ping -i inventory/hostsA resposta esperada é pong. Se houver erro, verifique suas chaves SSH e as regras de firewall do seu provedor de VDS.
- Execute o playbook em modo de dry-run (simulação) para visualizar as mudanças propostas sem aplicá-las:
ansible-playbook deploy.yml -i inventory/hosts --checkO Ansible retornará quantos nós serão alterados, adicionados ou removidos. Isso é crucial em ambientes de produção para evitar surpresas.
- Se o teste for bem-sucedido, execute a automação real:
ansible-playbook deploy.yml -i inventory/hostsO terminal exibirá o progresso de cada tarefa. Você verá mensagens indicando se uma ação foi executada (changed) ou se o estado já era o desejado (ok). Ao final, seu VDS Server terá o Docker instalado e um container Nginx rodando na porta 8080.
Passo 5: Validação e Verificação do Deploy
Após a execução bem-sucedida, é necessário validar se a infraestrutura está operante. Abra seu navegador e acesse http://IP_DO_VDS:8080. Você deve ver a página padrão de boas-vindas do Nginx.
Para verificar o status dos containers via linha de comando no VDS Server, utilize:
docker psVocê deverá ver o container web_app rodando. Para inspecionar logs ou entrar no shell do container, use:
docker exec -it web_app /bin/bashEssa validação manual é importante inicialmente, mas o objetivo final é confiar totalmente na automação. Em um cenário real de CI/CD (Integração Contínua e Entrega Contínua), esses passos seriam acionados automaticamente após cada commit no repositório Git.
Boas Práticas para Escalabilidade em VDS Server
A medida que sua infraestrutura cresce, manter playbooks monolíticos torna-se inviável. Considere as seguintes práticas para evoluir seu setup de DevOps:
Uso de Variáveis e Grupos: Em vez de hardcodar IPs ou portas, utilize arquivos group_vars e host_vars. Isso permite que você tenha um único playbook que se adapta a diferentes ambientes (dev, staging, prod) apenas alterando as variáveis.
Módulo Git para Código da Aplicação: Em vez de usar imagens públicas como o Nginx, use o módulo community.docker.docker_image para buildar imagens locais a partir de um Dockerfile clonado via Git. Isso garante que sua aplicação específica seja empacotada e distribuída.
Gestão de Segredos: Nunca armazene senhas ou chaves de API em texto puro no playbook. Utilize o Ansible Vault para criptografar arquivos sensíveis:
ansible-vault create secrets.yml
ansible-playbook deploy.yml --vault-password-file .vault_passAnálise de Logs e Monitoramento: A automação não substitui a observabilidade. Integre seus containers com ferramentas de log (como ELK Stack ou Loki) para monitorar a saúde da aplicação rodando no VDS.
Conclusão
A combinação de Ansible e Docker oferece uma solução robusta, escalável e padronizada para gerenciamento de infraestrutura em VDS Server. Ao automatizar o provisionamento do ambiente e o deploy das aplicações, equipes de desenvolvimento podem focar na lógica de negócio, enquanto a estabilidade e a consistência do ambiente são garantidas pela máquina.
Este tutorial cobriu desde a instalação das ferramentas até a execução de um playbook completo. A próxima etapa recomendada é integrar esse processo a um servidor Jenkins, GitLab CI ou GitHub Actions, criando um pipeline verdadeiramente automatizado que vai do código ao container em produção. Com essa base sólida, você está preparado para adotar práticas avançadas de DevOps e orquestração em larga escala.