<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ramon Risério Dourado Leite on Medium]]></title>
        <description><![CDATA[Stories by Ramon Risério Dourado Leite on Medium]]></description>
        <link>https://medium.com/@ramonriserio?source=rss-c0e488738463------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*GClIzF2xkKX3pHPRbF5O-g.jpeg</url>
            <title>Stories by Ramon Risério Dourado Leite on Medium</title>
            <link>https://medium.com/@ramonriserio?source=rss-c0e488738463------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 11:18:11 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ramonriserio/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Do Commit ao Deploy Seguro: Construindo um Pipeline CI Real com GitHub Actions]]></title>
            <link>https://medium.com/@ramonriserio/do-commit-ao-deploy-seguro-construindo-um-pipeline-ci-real-com-github-actions-9ab3b2243c8c?source=rss-c0e488738463------2</link>
            <guid isPermaLink="false">https://medium.com/p/9ab3b2243c8c</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Ramon Risério Dourado Leite]]></dc:creator>
            <pubDate>Fri, 05 Jun 2026 22:26:32 GMT</pubDate>
            <atom:updated>2026-06-05T22:26:32.189Z</atom:updated>
            <content:encoded><![CDATA[<p>No universo de Cloud e DevOps, o nosso principal objetivo é entregar valor de forma rápida, consistente e, acima de tudo, segura. Se você está começando sua jornada como Engenheiro Cloud ou DevOps, já deve ter percebido que a automação não é apenas um bónus - é uma necessidade absoluta.</p><p>Neste tutorial, vamos construir uma esteira de Integração Contínua (CI) completamente funcional utilizando o <strong>GitHub Actions</strong>. Vamos aprender a proteger a estabilidade do código utilizando testes automatizados, validadores de estilo (<em>Linters</em>) e gestão segura de credenciais em memória.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bnQuxJ5L5BDNLNp7Q4KcFg.png" /></figure><h3>1. O Ecossistema de Cloud e a Importância do CI</h3><p>Quando falamos sobre arquiteturas modernas em Cloud, o <strong>Kubernetes</strong> destaca-se como a plataforma open-source líder para a orquestração de containers, permitindo automatizar a implantação, o dimensionamento e a gestão de aplicações de forma isolada. Utilizá-lo na <strong>AWS (Amazon Web Services)</strong> — habitualmente através do serviço gerido <strong>Amazon EKS (Elastic Kubernetes Service)</strong> — traz o melhor dos dois mundos: a resiliência e a escalabilidade global da AWS combinadas com a flexibilidade do ecossistema Kubernetes.</p><p>Contudo, antes de fazer o deploy de qualquer microsserviço ou infraestrutura robusta num cluster Kubernetes na AWS, há um passo anterior indispensável na cultura DevOps: <strong>garantir a integridade do código através de um pipeline de Integração Contínua (CI)</strong>. Sem uma esteira de CI bem desenhada, corre-se o risco de enviar bugs, quebras de sintaxe ou, pior, falhas graves de segurança diretamente para o ambiente Cloud. É exatamente essa fundação essencial que vamos construir hoje de forma 100% prática.</p><h3>2. Pré-requisitos do Ambiente</h3><p>Para acompanhar este tutorial e executar o laboratório na totalidade, vamos precisar das seguintes ferramentas:</p><ul><li><strong>Conta AWS e AWS CLI:</strong> <br>Uma conta ativa na AWS. O AWS CLI deve estar instalado e configurado através do comando <em>aws configure</em> para garantir o acesso aos recursos de Cloud.</li><li><strong>Kubectl:</strong> <br>A ferramenta de linha de comandos necessária para interagir e gerir clusters Kubernetes.</li><li><strong>Git:</strong> <br>Essencial para o controle de versões do nosso código e comunicação com o GitHub.</li><li><strong>Editor de Código:</strong> <br>Recomendamos o VS Code ou qualquer outro de sua preferência.</li><li><strong>Conta no GitHub:</strong> <br>Onde nosso repositório remoto e as ações automatizadas do GitHub Actions vão ocorrer.</li></ul><h3>3. Passo a Passo Prático: Construindo o Pipeline</h3><p>O nosso projeto simulará um cenário real contendo um script de código principal em Python, testes unitários automatizados, um validador de estilo de código (<em>Linter</em>) e o consumo de uma chave de API secreta (mockada) como método de segurança.</p><p>Você pode copiar os arquivos deste projeto em <a href="https://github.com/ramonriserio/meu-projeto-ci">https://github.com/ramonriserio/meu-projeto-ci</a></p><h3>Passo 1: Estrutura do Repositório Local</h3><p>Abra seu editor de código, crie uma pasta para o projeto chamada <em>meu-projeto-ci</em> e monte exatamente a seguinte estrutura de diretórios e arquivos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/773/1*YWyjpvfMo8uaAFI5CBeT4Q.png" /></figure><p>Insira o respectivo conteúdo em cada um dos arquivos listados abaixo:</p><p>📂 <strong><em>requirements.txt</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/776/1*hSeueUvX3BX4DYCEZMP09A.png" /></figure><p>📂 <strong><em>app/main.py</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QfIwdsqBxFywM-yoFMp-yA.png" /></figure><p><em>📂 </em><strong><em>tests/test_main.py</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UnzwOKDhysxDUU0gOP0z8g.png" /></figure><p>📂<strong><em>.flake8</em></strong> <em>(Configuração visual para garantir a conformidade do código)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g3lNRzBtW0WE4tCaYW8KIg.png" /></figure><h3>Passo 2: Criando o Pipeline (.github/workflows/ci.yml)</h3><p>Alinhado com os conceitos modernos de <em>Pipeline as Code</em>, crie o arquivo descritivo da esteira utilizando a sintaxe nativa declarativa YAML. <em>Atenção redobrada com os espaços e recuos para evitar falhas de sintaxe:</em></p><p>📂 <strong><em>.github/workflows/ci.yml</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8HeqBXrM1-_ysS7eX-WSLA.png" /></figure><h3>Passo 3: Configurando o “Cofre Digital” (GitHub Secrets)</h3><p>Para atender aos critérios rígidos de segurança em Cloud, chaves e senhas nunca devem estar expostas diretamente no código de forma fixa (<em>hardcoded</em>). Segue as etapas abaixo para registar a credencial de forma segura na interface da plataforma:</p><ol><li>Acesse o <strong>GitHub</strong> e crie um novo repositório chamado meu-projeto-ci.</li><li>No menu superior horizontal do repositório, clique na engrenagem ⚙️ <strong>Settings</strong> (Configurações).</li><li>Na barra de navegação lateral esquerda, expanda <strong>Secrets and variables</strong> e clique em <strong>Actions</strong>.</li><li>Clique no botão verde <strong>New repository secret</strong>.</li><li>Preencha os campos seguindo rigorosamente este padrão:</li></ol><ul><li><strong>Name:</strong> MINHA_API_SECRET</li><li><strong>Secret:</strong> TokenSuperSecretoGeradoPelaPlataforma2026&lt;SEU_NOME&gt;</li></ul><p>6. Confirme clicando em <strong>Add secret</strong>.</p><blockquote>🔒 <strong><em>Nota de Segurança:</em></strong> <br>A partir deste momento, a plataforma criptografará e protegerá este valor. Caso seu código ou comandos tentem imprimir essa chave na tela, o mecanismo nativo de <strong>Log Masking</strong> ofuscará a saída, substituindo-a automaticamente por *** nos logs de execução.</blockquote><h3>Passo 4: Validando o Funcionamento (Simulação Real)</h3><p>Vamos reproduzir o comportamento real do fluxo de desenvolvimento de uma equipe de engenharia, simulando alterações numa branch separada para proteger a branch principal de produção (main).</p><h4>1. Criar e enviar (push) a base estável (branch main)</h4><p>Abra seu terminal na pasta raiz do teu projeto local (<em>meu-projeto-ci</em>) e execute os seguintes comandos para inicializar o Git e realizar o primeiro envio:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/774/1*0c9S7rVz_ekuyJUAZIX4pw.png" /></figure><blockquote>💡 <strong>DICA EXTRA DE AUTENTICAÇÃO DO GIT:</strong> <br>Se ao rodar o comando <em>git push</em> o terminal apresentar a falha <em>remote: Invalid username or token. Password authentication is not supported… fatal: Authentication failed</em>, sua máquina está tentando enviar credenciais antigas ou inválidas salvas no sistema. Como o GitHub não aceita mais senhas comuns no terminal desde 2021, você deve gerar um <strong><em>Personal Access Token (PAT)</em></strong>:</blockquote><ul><li><strong>Passo A:</strong> <strong>Limpar a credencial antiga do Windows</strong><br>No menu Iniciar do Windows, procure por <strong>Gerenciador de Credenciais</strong> (<em>Credential Manager</em>) → <strong>Credenciais do Windows</strong>. Procure por linhas que comecem com <em>git:https://github.com</em> ou <em>github.com</em> e clique em <strong>Remover</strong>.</li><li><strong>Passo B:</strong> <strong>Criar um Personal Access Token (PAT) no GitHub</strong><br>No site do GitHub, vai à tua foto de perfil → <strong>Settings</strong> → <strong>Developer Settings</strong> → <strong>Personal access tokens</strong> → <strong>Tokens (classic)</strong>. Clique em <strong>Generate new token (classic)</strong>. Dá um nome, define a expiração e marca as caixas <strong>repo</strong> (permissão para push) e <strong>workflow</strong> (permissão para usar o Actions). Gere e copie o token imediatamente (ghp_…).</li><li><strong>Passo C:</strong> <strong>Refazer o Push</strong><br>Execute <em>git push -u origin mai</em>n novamente e, quando pedir a senha, <strong>cole o Token</strong> gerado.</li></ul><h4>2. Criar uma branch de trabalho separada</h4><p>Agora, simulando uma alteração de rotina no código, crie uma ramificação secundária (<em>feature branch</em>):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/1*ct3PDR7OqbZlNPpckCDLcg.png" /></figure><p>Faça uma pequena alteração opcional em qualquer texto ou adicione um comentário no arquivo <em>app/main.py</em> para registar uma modificação. Em seguida, envie esta nova branch para o GitHub:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/1*LTnK_jXWGeXjv6bkth2q-g.png" /></figure><h4>3. Abrir o Pull Request</h4><p>Vai até à página do seu repositório no site do GitHub.</p><p><em>Nota:</em> Se a barra amarela com o botão “<em>Compare &amp; pull request</em>” não aparecer automaticamente (comportamento normal se a página demorar a atualizar ou se a branch já existir), faça o processo manualmente:</p><ol><li>Clique na aba <strong>Pull Requests</strong> logo abaixo do nome do repositório.</li><li>No canto superior direito, clique no botão verde <strong><em>New pull request</em></strong>.</li><li>Configure a seleção das branches desta forma:</li></ol><ul><li>À esquerda (base): <strong>main</strong></li><li>À direita (compare): <strong>feature/meu-teste</strong></li></ul><p>4. O GitHub validará se não existem conflitos estruturais (<em>Able to merge</em>). Clique em <strong><em>Create pull request</em></strong>, adicione um título descritivo e confirme novamente no botão <strong><em>Create pull request</em></strong>.</p><h4>4. Acompanhar a Execução da Esteira</h4><p>Assim que o Pull Request for aberto, o <strong>Gatilho Inteligente</strong> que configuramos detetará a ação. Na parte inferior da página do teu PR, verás o andamento do processo em tempo real:</p><ul><li>O GitHub Actions provisionará uma máquina virtual Linux isolada (<em>Runner</em>).</li><li>Realizará o download do teu código (<em>checkout</em>).</li><li>Configurará a versão estável do Python 3.11 tirando partido do sistema de cache.</li><li>Correrá o verificador de formatação estática <em>flake8</em>.</li><li>Injetará com total segurança em tempo de execução a credencial criptografada<em> ${{ secrets.MINHA_API_SECRET }}</em> na memória do ambiente virtual, concluindo a validação de testes do <em>pytest</em>.</li></ul><p>Se todas as etapas forem bem-sucedidas, a interface do GitHub exibirá um <strong>check verde</strong>, indicando que o código cumpre os padrões de qualidade e segurança e está pronto para sofrer a integração (<em>Merge</em>) de forma totalmente segura!</p><p><strong>EVIDÊNCIA 01: </strong>Erro detalhado do pull request.</p><h3>🚨 Guia de Resolução de Problemas (Troubleshooting)</h3><p>Se seu pipeline falhar e ficar vermelho, não entre em pânico! A leitura correta do <em>Stack Trace</em> nos logs do GitHub Actions resolverá o problema rapidamente:</p><ul><li><strong>Falha na etapa do Linter (Flake8):</strong> <br>O ecossistema Python adota padrões estéticos rígidos (PEP 8). Se você deixar espaços em branco desnecessários no final de uma linha, esquecer quebras de linha duplas entre funções ou errar nos recuos (identação), o <em>Flake8</em> interromperá o fluxo de propósito. Abra o log detalhado, localize a linha indicada, corrija-a localmente no seu editor, faça um novo <em>git commit</em> e <em>git push</em>. O pipeline reiniciará automaticamente.</li><li><strong>Falha na etapa do PyTest:</strong> <br>Se os testes quebrarem acusando erro na chamada de API, verifique detalhadamente se o nome que está inserido no cofre do GitHub Secrets é exatamente igual a <em>MINHA_API_SECRET</em>. Uma única letra divergente ou espaço oculto impedirá que a biblioteca os recolha a variável em memória, gerando a exceção ValueError planeada na nossa aplicação.</li></ul><p><strong>EVIDÊNCIA 02: </strong>Pull request sem erros.</p><h3>5. Conclusão e Próximos Passos</h3><p>Parabéns! Você acabou de construir um pipeline de Integração Contínua (CI) real e seguro do zero. Com esta experiência, você garantiu conhecimentos práticos em:</p><ul><li>Configuração de fluxos orientados a eventos com GitHub Actions.</li><li>Execução automatizada de testes estáticos e unitários.</li><li>Gestão e injeção segura de segredos em memória voltada para boas práticas de Cloud Security.</li></ul><p><strong>Próximos passos sugeridos:</strong> <br>Como desafio, tente estender este pipeline adicionando uma etapa de <em>Continuous Delivery</em> (CD) que construa uma imagem Docker da aplicação e faça o envio automatizado para o Amazon ECR (Elastic Container Registry) da AWS, preparando o terreno para a posterior orquestração no Kubernetes.</p><p>Gostou deste laboratório prático? Deixa o teu 👏, partilhe com a sua equipe e comente abaixo se você conseguiu colocar sua esteira para executar com sucesso!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9ab3b2243c8c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ansible Intelligence: Como usar Facts e Condicionais para gerenciar Ambientes Multi-Distro]]></title>
            <link>https://medium.com/@ramonriserio/ansible-intelligence-como-usar-facts-e-condicionais-para-gerenciar-ambientes-multi-distro-e06dad73a311?source=rss-c0e488738463------2</link>
            <guid isPermaLink="false">https://medium.com/p/e06dad73a311</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Ramon Risério Dourado Leite]]></dc:creator>
            <pubDate>Thu, 16 Apr 2026 23:59:17 GMT</pubDate>
            <atom:updated>2026-04-16T23:59:54.702Z</atom:updated>
            <content:encoded><![CDATA[<p>No mundo real da Engenharia de Cloud, raramente trabalhamos com um único sabor de Linux. Em um mesmo projeto, você pode encontrar <strong>Amazon Linux</strong> (família RedHat) para instâncias de aplicação e <strong>Debian/Ubuntu</strong> para serviços específicos dentre outros.</p><p>Como gerenciar todos esses servidores com um único Playbook sem criar redundâncias? A resposta está nos <strong>Ansible Facts</strong> e nas <strong>Estruturas Condicionais</strong>.</p><p>Neste hands-on, vamos configurar servidores web em diferentes distribuições usando uma única lógica de automação.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ans7atw00nlIfRhboZtuyw.png" /></figure><h3>Cenário e Pré-requisitos</h3><p>Para este laboratório, utilizaremos 4 instâncias EC2:</p><ul><li><strong>Nó de controle:</strong> Amazon Linux com Ansible instalado.</li><li><strong>Host01 e Host02:</strong> Amazon Linux / RHEL (ansible_user=ec2-user).</li><li><strong>Host03:</strong> Debian 12 (ansible_user=admin).</li><li><strong>Dependência:</strong><br>Para que o Ansible gerencie os nós gerenciados, eles precisam do pacote <em>python3-PyMySQL</em> instalado.</li></ul><blockquote><strong>Dica:<br></strong>Se você caiu aqui de paraquedas e ainda não configurou seu ambiente, recomendo conferir nosso guia de <a href="https://medium.com/@ramonriserio/primeiros-passos-com-ansible-na-aws-criando-seu-laborat%C3%B3rio-do-zero-765d1b9688ba">Primeiros Passos com Ansible na AWS</a>.</blockquote><h3>Passo 1: Atualizando o Inventário</h3><p>Certifique-se de que seu arquivo hosts reflete essa realidade:</p><pre>host01 ansible_host=IP_HOST_01 ansible_user=ec2-user<br>host02 ansible_host=IP_HOST_02 ansible_user=ec2-user<br>host03 ansible_host=IP_HOST_03 ansible_user=admin<br><br>[all:vars]<br>ansible_ssh_private_key_file=ansible-key.pem</pre><p><em>Substitua os IP_HOSTs acima pelos IPs privados de suas instâncias e também substitua seu arquivo .pem.</em></p><p>Teste a conectividade:</p><pre>ansible all -m ping -i hosts</pre><h3>Passo 2: O Poder dos Ansible Facts</h3><p>O Ansible coleta automaticamente informações detalhadas do sistema de destino (Facts). Para entender como aplicar condicionais, precisamos saber como o Ansible identifica cada sistema.</p><p>Execute o comando abaixo para filtrar a família do sistema operacional:</p><pre>ansible all -m setup -a &quot;filter=ansible_os_family&quot; -i hosts</pre><p>Você verá que o <strong>Host01/02</strong> retornará RedHat, enquanto o <strong>Host03</strong> retornará Debian. É com essa variável que nossa automação tomará decisões.</p><h3>Passo 3: Implementando Condicionais (O Playbook)</h3><p>Agora, vamos criar um Playbook inteligente. O desafio é: o pacote do servidor web no RedHat chama-se <em>httpd</em>, mas no Debian chama-se apache2.</p><p>Crie o arquivo <em>install_apache.yml</em>:</p><pre>---<br>- name: Instalando Apache em Multi-Distro<br>  hosts: all<br>  become: yes<br><br>  tasks:<br>  - name: Instalando Apache no RedHat Family (Amazon Linux)<br>    yum:<br>      name: httpd<br>      state: latest<br>    when: ansible_os_family == &quot;RedHat&quot;<br><br>  - name: Instalando Apache no Debian Family<br>    apt:<br>      name: apache2<br>      state: latest<br>      update_cache: yes<br>    when: ansible_os_family == &quot;Debian&quot;<br><br>  - name: Garantindo que o Apache esteja rodando (RedHat)<br>    service:<br>      name: httpd<br>      state: started<br>    when: ansible_os_family == &quot;RedHat&quot;<br><br>  - name: Garantindo que o Apache esteja rodando (Debian)<br>    service:<br>      name: apache2<br>      state: started<br>    when: ansible_os_family == &quot;Debian&quot;</pre><h4>Por que isso é importante?</h4><p>A cláusula <em>when</em> verifica a condição no nó de destino. Se o host for Debian, ele ignora as tarefas de <em>yum</em> e executa apenas as de <em>apt</em>. Isso mantém seu código limpo e funcional para todo o parque de servidores.</p><h4>Validar a Sintaxe (Opcional, mas recomendado)</h4><p>Antes de rodar “para valer”, é uma boa prática verificar se a indentação do YAML está correta:</p><pre>ansible-playbook install_apache.yml -i hosts --syntax-check</pre><h4>Executar o Playbook</h4><p>Agora, execute o comando principal para iniciar a instalação:</p><pre>ansible-playbook install_apache.yml -i hosts</pre><h4>O que vai acontecer durante a execução?</h4><p>O Ansible é esperto o suficiente para ler as suas condicionais (when). Veja como ele se comportará no seu terminal:</p><ol><li><strong>Gathering Facts:</strong> <br>Ele vai se conectar aos 3 hosts e descobrir que o Host01/02 são <strong>RedHat</strong> e o Host03 é <strong>Debian</strong>.</li><li><strong>Tasks de RedHat:</strong> <br>Nos <strong>Host01/02</strong>, ele vai instalar o httpd.</li><li><strong>Tasks de Debian:<br></strong>No <strong>Host03</strong>, você verá a mensagem skipping (pulando), porque a condição ansible_os_family == &quot;RedHat&quot; será falsa para ele.</li></ol><h4>Dica de Ouro: Verificação Rápida</h4><p>Após a execução, você pode validar se o serviço está rodando em todos os hosts sem precisar entrar neles um por um, usando um comando ad-hoc:</p><ul><li><strong>Para os Hosts RedHat:</strong></li></ul><pre>ansible webservers -m shell -a &quot;systemctl status httpd&quot; -i hosts</pre><ul><li><strong>Para o Host Debian:</strong></li></ul><pre>ansible host03 -m shell -a &quot;systemctl status apache2&quot; -i hosts</pre><p>Se no final você vir o status <strong>“active (running)”</strong> em todos, sua automação multi-distro foi um sucesso absoluto!</p><h4>Desafio de Idempotência (Shell vs Service)</h4><p>Muitos iniciantes usam o módulo <em>shell</em> para gerenciar serviços, mas isso quebra a <strong>idempotência</strong> (a capacidade de rodar o código várias vezes sem causar efeitos colaterais).</p><p><strong>Evite isso:</strong></p><pre>  - name: Reiniciar Apache (Não recomendado)<br>    shell: systemctl restart httpd</pre><p><strong>Prefira isso:</strong></p><pre>  - name: Garantir estado do serviço (Recomendado)<br>    service:<br>      name: httpd<br>      state: started</pre><p>O módulo <em>service</em> verifica se o serviço já está rodando. Se estiver, ele não faz nada. O módulo <em>shell</em> sempre executará o comando, gastando recursos desnecessários.</p><h3>Passo 4: Deploy de Conteúdo Customizado</h3><p>Para finalizar, vamos criar uma página HTML e enviá-la para o <strong>Host02</strong>.</p><ol><li>Crie um arquivo <em>index.html</em> localmente com uma mensagem de sucesso.<br>Por exemplo:</li></ol><pre>&lt;!DOCTYPE html&gt;<br>&lt;html&gt;<br>&lt;head&gt;<br>    &lt;title&gt;Sucesso&lt;/title&gt;<br>&lt;/head&gt;<br>&lt;body&gt;<br>    &lt;h1&gt;Sucesso!&lt;/h1&gt;<br>    &lt;p&gt;O servidor está funcionando e o deploy foi concluído.&lt;/p&gt;<br>&lt;/body&gt;<br>&lt;/html&gt;</pre><p>2. Use o comando <em>ad-hoc</em> a seguir para copiar o arquivo:</p><pre>ansible host02 -m copy -a &quot;src=index.html dest=/var/www/html/index.html&quot; -i hosts --become</pre><p>Acesse o IP público do Host02 no navegador e você verá sua página personalizada!</p><blockquote><strong>Dica:<br></strong><em>Lembre-se de liberar o acesso à porta 80 no security group para conseguir acessar a página no navegador.</em></blockquote><h3>Conclusão</h3><p>Neste tutorial, você aprendeu a:</p><ol><li>Inspecionar hosts usando <em>ansible-facts</em>.</li><li>Usar a cláusula <em>when</em> para criar automações flexíveis.</li><li>Diferenciar o uso de módulos declarativos (<em>service</em>) de comandos imperativos (<em>shell</em>).</li></ol><p>Dominar condicionais é o que permite que sua infraestrutura escale de forma organizada, independente de quantas distribuições diferentes você precise gerenciar.</p><p><strong>Gostou deste hands-on?</strong> <br>Deixe seu 👏 e siga para mais conteúdos de Cloud e Automação! 🚀</p><p><em>Publicado originalmente na série Ansible Mastery.</em></p><p><strong>#DevOps #Ansible #AWS #Linux #CloudComputing</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e06dad73a311" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ansible Variables: Configurando infraestrutura com Playbooks Dinâmicos]]></title>
            <link>https://medium.com/@ramonriserio/ansible-variables-configurando-infraestrutura-com-playbooks-din%C3%A2micos-42adfa3c91bf?source=rss-c0e488738463------2</link>
            <guid isPermaLink="false">https://medium.com/p/42adfa3c91bf</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Ramon Risério Dourado Leite]]></dc:creator>
            <pubDate>Mon, 06 Apr 2026 00:25:08 GMT</pubDate>
            <atom:updated>2026-04-14T22:51:27.854Z</atom:updated>
            <content:encoded><![CDATA[<p>Se você está trilhando o caminho de <strong>Cloud Engineer</strong> ou <strong>DevOps</strong>, já percebeu que a automação só é verdadeiramente poderosa quando é flexível. No Ansible, o segredo dessa flexibilidade atende por um nome: <strong>Variáveis</strong>.</p><p>Neste hands-on, vamos explorar como as variáveis permitem que um único Playbook seja executado em diferentes ambientes (Dev, QA, Prod) sem que você precise alterar uma única linha de código lógico. Vamos do inventário ao debug avançado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cCuJDpS7fmuC-Zv2.png" /></figure><h3>Por que usar Variáveis?</h3><p>Imagine gerenciar 100 servidores e precisar alterar a porta de um serviço em todos eles. Sem variáveis, você teria um trabalho manual exaustivo. Com variáveis, você define o valor em um lugar e o Ansible o distribui para todos os cantos. Elas são essenciais para a <strong>padronização</strong> e <strong>reutilização</strong> de código.</p><h3>Pré-requisitos</h3><p>Para este laboratório, você precisará de:</p><ol><li><strong>Nó de Controle:</strong> Uma máquina com Ansible instalado.</li><li><strong>Nós Gerenciados:</strong> Um servidor <strong>RHEL</strong> e outro <strong>Debian</strong>.</li><li><strong>Conectividade:</strong> SSH funcionando e permissão de sudo no destino.</li><li><strong>Dependência:</strong><br>Para que o Ansible gerencie os nós gerenciados, eles precisam do pacote <em>python3-PyMySQL</em> instalado.</li></ol><blockquote><strong><em>Dica:<br></em></strong><em>Se você caiu aqui de paraquedas e ainda não configurou seu ambiente, recomendo conferir nosso guia de </em><a href="https://medium.com/@ramonriserio/primeiros-passos-com-ansible-na-aws-criando-seu-laborat%C3%B3rio-do-zero-765d1b9688ba"><em>Primeiros Passos com Ansible na AWS</em></a><em>.</em></blockquote><h3>Passo 1: Variáveis no Arquivo de Inventário</h3><p>O primeiro lugar onde definimos variáveis é no arquivo hosts. Aqui, atrelamos informações específicas a cada máquina ou grupo.</p><p>Crie o diretório ansible-variables e o arquivo <em>hosts</em> com o conteúdo abaixo.</p><pre># Arquivo: hosts<br>host01 ansible_host=172.31.20.169 ansible_user=admin<br>host02 ansible_host=172.31.26.209 ansible_user=ec2-user<br><br>[all:vars]<br>ansible_ssh_private_key_file=ansible-key.pem<br><br>[webservers]<br>host01</pre><blockquote><strong>Nota 1:</strong> <br>As variáveis de conexão (como ansible_user e ansible_host) são reservadas pelo Ansible para gerenciar o acesso SSH.</blockquote><blockquote><strong>Nota 2:<br></strong>Substitua os IPs acima pelos seus IPs privados e também seus respectivos usuários.</blockquote><blockquote><strong>Nota 3:</strong><br>Substitua a chave privada acima pela sua chave privada.</blockquote><h3>Passo 2: Declarando Variáveis no Playbook (YAML)</h3><p>Dentro de um Playbook, podemos organizar dados de três formas principais: Strings simples, Listas e Dicionários.</p><p>Crie um arquivo chamado <em>variables-example.yml</em>:</p><pre>---<br>- name: Hands-on de Variáveis<br>  hosts: localhost # Execução local para teste<br>  vars:<br>    # Variável Simples (Key: Value)<br>    http_port: 80<br> <br>    # Lista (Perfeito para pacotes)<br>    packages:<br>      - git<br>      - curl<br>      - wget<br> <br>    # Dicionário (Para dados estruturados)<br>    appserver:<br>      hostname: webapp01<br>      ipaddress: 10.0.0.15<br><br>  tasks:<br>    - name: Exibindo valores com o módulo debug<br>      debug:<br>        msg: &quot;Servidor {{ appserver.hostname }} opera na porta {{ http_port }}&quot;</pre><p>Para rodar:</p><pre>ansible-playbook variables-example.yml</pre><blockquote><strong>Evidência 01:</strong><br>Print do resultado do comando acima.</blockquote><h3>Passo 3: Variáveis de Fato (Ansible Facts)</h3><p>O Ansible é “inteligente”. <br>Toda vez que você roda um Playbook, ele executa uma tarefa implícita chamada Gathering Facts. Ele coleta informações do sistema operacional, memória e rede do host de destino.</p><p>Tente inspecionar seu sistema com este comando:</p><pre>ansible all -m setup -i hosts</pre><p><strong>O que esse comando faz?</strong></p><ul><li><strong>all</strong>: <br>Alvo são todos os hosts do inventário.</li><li><strong>-m setup</strong>: <br>Chama o módulo setup, que é o responsável por “entrevistar” a máquina e coletar os Facts.</li><li><strong>-i hosts</strong>: <br>Aponta para o seu arquivo de inventário.</li></ul><blockquote><strong>Evidência 02:</strong><br>Print do resultado do comando acima.</blockquote><h3>Passo 4: Variáveis Dinâmicas e em Tempo de Execução</h3><p>Às vezes, você só sabe o valor de uma variável quando o processo está rodando. Para isso, usamos <em>register</em> e <em>set_fact</em>.</p><h4>Usando o register</h4><p>O <em>register</em> captura a saída de um comando para usar depois.<br>Crie o arquivo <em>check_nginx.yml</em> com o conteúdo abaixo.</p><pre>---<br>- name: Playbook para testar Variáveis Dinâmicas (Register)<br>  hosts: localhost<br>  become: yes  # Necessário para checar status de serviços do sistema<br><br>  tasks:<br>    - name: Checar status do Nginx<br><br>      # O comando &#39;shell&#39; executa o comando no terminal do host de destino<br>      shell: systemctl is-active nginx<br><br>      # O &#39;register&#39; captura o objeto de resposta do comando acima e o salva em &#39;nginx_status&#39;<br>      register: nginx_status<br><br>      # Ignoramos erros para que o playbook não pare caso o Nginx esteja parado<br>      ignore_errors: yes<br><br>    - name: Exibir a saída do comando capturado<br>      debug:<br>        msg: &quot;O status do Nginx é: {{ nginx_status.stdout }}&quot;<br><br>    - name: Exibir todo o conteúdo do register (para fins de aprendizado)<br>      debug:<br>        var: nginx_status</pre><p>Para rodar:</p><pre>ansible-playbook check_nginx.yml</pre><blockquote><strong>Evidência 03:</strong><br>Print do resultado do comando acima e explicação do erro “fatal” (em vermelho).</blockquote><h4>Usando o set_fact</h4><p>O <em>set_fact</em> cria uma nova variável durante o “vôo”.<br>Acrescente o código abaixo no arquivo <em>check_nginx.yml.</em></p><pre>    - name: Definir variável de log<br>      set_fact:<br>        caminho_log: &quot;/var/log/app_custom.log&quot;</pre><p>Para rodar:</p><pre>ansible-playbook check_nginx.yml</pre><blockquote><strong>Evidência 04:</strong><br>Print do resultado do comando acima.</blockquote><h3>Passo 5: Sobrescrevendo via Linha de Comando</h3><p>Precisa mudar um valor de última hora sem mexer no arquivo? <br>Use a flag <em>-e</em> (extra vars). Esta é a variável com <strong>maior poder de precedência</strong>.</p><pre>ansible-playbook variables-example.yml -e &quot;http_port=8080&quot;</pre><blockquote><strong>Evidência 05:</strong><br>Print do resultado do comando acima.</blockquote><h4>A Regra de Ouro: Precedência de Variáveis</h4><p>O Ansible tem uma hierarquia de quem “manda” mais se houver nomes repetidos. <br>Do menor para o maior poder:</p><ol><li>Variáveis de Role (<em>defaults/main.yml</em>)</li><li>Variáveis de Inventário (Arquivo<em> hosts</em>)</li><li>Variáveis do Playbook (<em>vars:</em>)</li><li>Variáveis registradas (<em>set_fact </em>/ <em>register</em>)</li><li><strong>Extra Vars (<em>-e</em> via terminal) - o vencedor absoluto.</strong></li></ol><h3>Exemplo Prático: Um Playbook, Múltiplos Ambientes (Dev, QA, Prod)</h3><p>No mundo real, você não quer ter três Playbooks diferentes para instalar o mesmo servidor web. Você quer <strong>um único código</strong> que saiba que em <strong>Desenvolvimento</strong> usamos a porta 8080, em <strong>QA</strong> a porta 9090 e em <strong>Produção</strong> a porta padrão 80.</p><p>Veja como estruturar isso:</p><h4>0. Criando a Estrutura de Variáveis</h4><p>Em vez de colocar os valores dentro do Playbook, vamos criar uma pasta chamada group_vars. O Ansible lerá automaticamente os arquivos dentro dessa pasta se o nome do arquivo coincidir com o nome do grupo no seu inventário.</p><p>O erro mais comum neste é a estrutura de pastas. O Ansible precisa que a pasta group_vars esteja no mesmo nível do seu arquivo de inventário ou do seu Playbook.</p><p>A estrutura ideal de arquivos deve ser esta:</p><p><em>projeto-ansible/</em><br>├── <em>hosts</em> ← O grupo [dev] está aqui<br>├── <em>deploy-app.yml</em> ← O Playbook está aqui<br>└── <em>group_vars/</em> ← Pasta SEMPRE no mesmo nível do Playbook/Inventário<br> …….├── <em>dev.yml</em> ← Variável env_name está aqui<br>……. └── <em>prod.yml</em></p><p><strong>Crie a estrutura:</strong></p><pre>mkdir projeto-automacao &amp;&amp; cd projeto-automacao<br>mkdir group_vars<br>touch hosts deploy-app.yml<br>touch group_vars/dev.yml group_vars/prod.yml</pre><h4><strong>1. O Inventário Heterogêneo (hosts)</strong></h4><p>Diferente de um ambiente padronizado, aqui temos usuários diferentes para cada host. Vamos declarar isso diretamente no arquivo hosts:</p><pre>[dev]<br>host01 ansible_host=172.31.20.169 ansible_user=admin<br><br>[prod]<br>host02 ansible_host=172.31.26.209 ansible_user=ec2-user<br><br>[all:vars]<br>ansible_ssh_private_key_file=./ansible-key.pem</pre><blockquote><strong>Nota</strong><em>: <br>Certifique-se de que o arquivo .pem está nesta mesma pasta e com permissão chmod 400.</em></blockquote><h4>2. Definindo os Valores por Ambiente</h4><p>Como o host01 (Dev) e o host02 (Prod) podem ter sistemas operacionais diferentes, vamos abstrair o nome do pacote e o caminho das configurações.</p><p><strong>Em group_vars/dev.yml (Ambiente Debian/Ubuntu):</strong></p><pre>env_name: &quot;Desenvolvimento&quot;<br>http_port: 8080<br>apache_package: &quot;apache2&quot;<br>apache_config_path: &quot;/etc/apache2/ports.conf&quot;</pre><p><strong>Em group_vars/prod.yml (Ambiente RHEL/Amazon Linux):</strong></p><pre>env_name: &quot;PRODUÇÃO&quot;<br>http_port: 80<br>apache_package: &quot;httpd&quot;<br>apache_config_path: &quot;/etc/httpd/conf/httpd.conf&quot;</pre><h4>3. O Playbook Único, Universal e Inteligente (<em>deploy-app.yml</em>)</h4><p>Repare que o código abaixo não contém valores fixos, apenas as “etiquetas” (variáveis).</p><pre>---<br>- name: Deploy de Infraestrutura Multicloud<br>  hosts: all<br>  become: yes<br><br>  tasks:<br>    - name: Diagnóstico do ambiente<br>      debug:<br>        msg: &quot;Conectado em {{ env_name }} como usuário {{ ansible_user }}&quot;<br><br>    - name: Instalar Servidor Web<br>      package:<br>        name: &quot;{{ apache_package }}&quot;<br>        state: present<br><br>    - name: Configurar porta do Servidor<br>      lineinfile:<br>        path: &quot;{{ apache_config_path }}&quot;<br>        regexp: &#39;^Listen &#39;<br>        line: &quot;Listen {{ http_port }}&quot;<br>      notify: Reiniciar Servidor Web<br><br>  handlers:<br>    - name: Reiniciar Servidor Web<br>      service:<br>        name: &quot;{{ apache_package }}&quot;<br>        state: restarted<br>        enabled: yes</pre><h4>4. A Execução Seletiva</h4><p>Agora, a mágica acontece no terminal. O Ansible decide quais variáveis usar baseado no grupo de hosts que você aponta.</p><p>Para rodar o deploy, você deve estar na pasta raiz do projeto (onde está o arquivo hosts).</p><p><strong>Para rodar em Dev:</strong></p><pre>ansible-playbook deploy-app.yml -i hosts -l dev</pre><blockquote><strong>Evidência 06</strong>:<br>Print do resultado do comando acima</blockquote><p><strong>Para rodar em Prod:</strong></p><pre>ansible-playbook deploy-app.yml -i hosts -l prod</pre><blockquote><strong>Evidência 07</strong>:<br>Print do resultado do comando acima</blockquote><blockquote><strong>Dica de Ouro:</strong> <br>Se precisar validar a conexão antes de rodar o deploy, use o comando:</blockquote><pre>ansible all -m ping -i hosts</pre><h4>Por que isso é incrível?</h4><ol><li><strong>Segurança:</strong> <br>Você evita erros humanos ao não precisar editar o código principal para mudar uma porta ou um IP.</li><li><strong>Escalabilidade:</strong> <br>Se surgir um novo ambiente (ex: homolog), basta criar um novo arquivo em group_vars/ sem tocar no Playbook.</li></ol><blockquote><strong>Auditoria</strong>: <br>Você consegue ver claramente as diferenças de configuração entre seus ambientes apenas comparando os arquivos de variáveis.</blockquote><h3>Conclusão</h3><p>Dominar variáveis é o que separa um executor de comandos de um verdadeiro <strong>Engenheiro de Automação</strong>. Elas permitem que sua infraestrutura seja tratada como código de forma dinâmica e escalável.</p><p>Gostou deste guia? <br>Não esqueça de deixar seu 👏 e compartilhar com a comunidade DevOps! 🚀</p><p><strong>#DevOps #Ansible #AWS #CloudComputing #Linux</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=42adfa3c91bf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automatizando configuração do MariaDB no RHEL com Ansible: Do Zero ao Deploy Seguro]]></title>
            <link>https://medium.com/@ramonriserio/automatizando-configura%C3%A7%C3%A3o-do-mariadb-no-rhel-com-ansible-do-zero-ao-deploy-seguro-1e260ffed47e?source=rss-c0e488738463------2</link>
            <guid isPermaLink="false">https://medium.com/p/1e260ffed47e</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Ramon Risério Dourado Leite]]></dc:creator>
            <pubDate>Tue, 31 Mar 2026 19:59:35 GMT</pubDate>
            <atom:updated>2026-04-01T14:18:20.144Z</atom:updated>
            <content:encoded><![CDATA[<p>Este é o próximo nível da nossa jornada de automação! No tutorial <a href="https://medium.com/@ramonriserio/ansible-playbooks-automatizando-a-configura%C3%A7%C3%A3o-de-um-servidor-web-nginx-ab0929087108">anterior</a>, fizemos a automação da configuração de um servidor Nginx no Debian utilizando <strong>Ansible</strong>. Agora, vamos fazer o mesmo com o MariaDB no RHEL (<strong>Infraestrutura como Código (IaC)</strong> utilizando <strong>Ansible</strong>).</p><p>O objetivo aqui é que você consiga apertar um botão e ter um banco de dados pronto, seguro e configurado em segundos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/886/1*v5Lw4rzzJHMs_zeNjDG_xQ.png" /></figure><p>Se você é um aspirante a DevOps ou atua com Cloud, saber configurar um banco de dados de forma segura é uma habilidade indispensável. No Red Hat Enterprise Linux, o processo envolve não apenas a instalação, mas também o gerenciamento rigoroso de serviços, segurança de acesso e regras de firewall.</p><p>Se você fizesse a instalação manual do MariaDB no RHEL, perceberia que são muitos comandos, edições de firewall e scripts interativos. No mundo DevOps, “repetição manual” é sinônimo de erro. Por isso, neste hands-on, vamos criar um <strong>Playbook</strong> que orquestra toda essa instalação de forma impecável e idempotente.</p><h3>Pré-requisitos</h3><p>Para este laboratório, você precisará de:</p><ol><li><strong>Nó de Controle:</strong> Uma máquina com Ansible instalado.</li><li><strong>Nó Gerenciado:</strong> Um servidor <strong>RHEL</strong>.</li><li><strong>Conectividade:</strong> SSH funcionando e permissão de sudo no destino.</li><li><strong>Dependência:</strong> <br>Para que o Ansible gerencie o MariaDB, o nó gerenciado precisa do pacote python3-PyMySQL instalado (vamos incluir isso no playbook!).</li></ol><blockquote><strong><em>Dica:<br></em></strong><em>Se você caiu aqui de paraquedas e ainda não configurou seu ambiente, recomendo conferir nosso guia de </em><a href="https://medium.com/@ramonriserio/primeiros-passos-com-ansible-na-aws-criando-seu-laborat%C3%B3rio-do-zero-765d1b9688ba"><em>Primeiros Passos com Ansible na AWS</em></a><em>.</em></blockquote><h3>Passo 1: Estrutura do Projeto</h3><p>No nó de controle, crie uma pasta dedicada para este projeto:</p><pre>mkdir ansible-mariadb &amp;&amp; cd ansible-mariadb</pre><p>Crie o arquivo de inventário <em>hosts</em> e inclua:</p><pre>[dbservers]<br># Substitua pelo IP privado do seu servidor RHEL e o caminho de sua chave .pem<br>172.31.26.209 ansible_user=ec2-user ansible_ssh_private_key_file=/home/ec2-user/lab_nginx/aula06-key.pem</pre><h3>Passo 2: O Playbook (mariadb_playbook.yml)</h3><p>Diferente da instalação manual, onde executaríamos um script, usaremos módulos do Ansible que garantem o mesmo nível de segurança (hardening) de forma automatizada.</p><p>Primeiro, crie o arquivo <em>mariadb_playbook.yml</em>.</p><h4>2.1. Configuração do Alvo e Privilégios</h4><p>Nesta etapa inicial, definimos <strong>onde</strong> o Ansible deve atuar.</p><ul><li><strong>hosts: dbservers</strong>: <br>Indica que as tarefas serão executadas apenas nas máquinas listadas sob esse grupo no seu arquivo de inventário.</li><li><strong>become: yes</strong>: <br>É o equivalente ao sudo. Como estamos instalando software e alterando configurações de sistema, precisamos de privilégios de superusuário.</li></ul><pre>---<br>- name: Automação Completa do MariaDB no RHEL<br>  hosts: dbservers<br>  become: yes</pre><h4>2.2. Definição de Variáveis (vars)</h4><p>Em vez de escrever senhas e nomes de bancos diretamente nas tarefas (“hardcoded”), usamos variáveis.</p><p>Isso torna o código reutilizável. Se precisar mudar a senha, você altera em um só lugar. Aqui definimos a senha do root, o nome do banco da aplicação (lab_db) e as credenciais do usuário final.</p><pre>  vars:<br>    db_root_password: &quot;SenhaSeguraDoRoot123&quot;<br>    app_db_name: &quot;lab_db&quot;<br>    app_db_user: &quot;lab_user&quot;<br>    app_db_password: &quot;SenhaDificil123&quot;</pre><h4>2.3. Instalação de Pacotes e Dependências</h4><p>Aqui o Ansible utiliza o módulo <strong>dnf</strong> (padrão do RHEL).</p><ul><li>Além do <em>mariadb-server</em>, instalamos o <em>python3-PyMySQL</em>, o suporte <em>python3-firewall</em> e o <em>firewalld</em>.</li><li><strong>Por que?</strong> <br>O Ansible é escrito em Python. Para que ele consiga entrar no MariaDB e executar comandos de criação de usuários e bancos (nos passos seguintes), ele precisa dessa biblioteca instalada no servidor alvo.<br><strong>firewalld (O Serviço):</strong> <br>É o daemon do sistema operacional responsável por controlar as tabelas de filtragem de pacotes. Sem ele, a porta 3306 permanece fechada e o comando systemctl start firewalld falha porque o &quot;motor&quot; do firewall não existe no servidor.<br><strong>python3-firewall (A Ponte):</strong> <br>O Ansible não &quot;digita&quot; comandos no terminal; ele executa módulos Python. Esta biblioteca permite que os scripts Python do Ansible conversem diretamente com o serviço firewalld. Sem ela, o Ansible exibe o erro de <em>“Failed to import the required Python library”</em>.</li></ul><pre>  tasks:<br>    - name: Instalar pacotes do MariaDB e dependência Python<br>      dnf:<br>        name: <br>          - mariadb-server<br>          - python3-PyMySQL # Necessário para os módulos mysql_ do Ansible<br>          - firewalld<br>          - python3-firewall<br>        state: latest<br>        update_cache: yes</pre><h4>2.4. Ativação do Serviço</h4><p>Após instalar, o software está “parado”.</p><p>Usamos o módulo <strong>service</strong> para garantir que o MariaDB esteja rodando (state: started) e configurado para iniciar sozinho caso o servidor seja reiniciado (enabled: yes).</p><pre>    - name: Garantir que o MariaDB está rodando e habilitado<br>      service:<br>        name: mariadb<br>        state: started<br>        enabled: yes</pre><p>Depois, usamos o módulo <strong>wait_for</strong> para esperar que o MariaDB esteja pronto antes de configurar a senha do root.</p><pre>    - name: Aguardar o socket do MariaDB estar pronto<br>      wait_for:<br>        path: /var/lib/mysql/mysql.sock<br>        state: present<br>        timeout: 30</pre><h4>2.5. Configuração de Segurança do Root</h4><p>Este é o início do “Hardening”.<br>(O Hardening é um processo de segurança cibernética que visa reduzir a superfície de ataque de um sistema, tornando-o mais resistente a invasões.)</p><ul><li>Utilizamos o módulo <strong><em>mysql_user</em></strong> para definir a senha do administrador principal.</li><li>Os parâmetros <em>login_unix_socket</em> e <em>check_implicit_admin: ye</em>s permitem que o Ansible faça essa primeira alteração usando a autenticação do sistema operacional, sem precisar de senha prévia.</li></ul><pre>    - name: Configurar a senha do root do MariaDB<br>      mysql_user:<br>        name: root<br>        password: &quot;{{ db_root_password }}&quot;<br>        login_user: root<br>        login_password: &quot;{{ db_root_password }}&quot;<br>        login_unix_socket: /var/lib/mysql/mysql.sock<br>        check_implicit_admin: yes # Essencial para a primeira execução sem senha<br>        state: present</pre><h4>2.6. Limpeza de Vulnerabilidades (Hardening)</h4><p>O MariaDB vem por padrão com algumas brechas de segurança para facilitar testes, que removeremos agora:</p><ul><li><strong>Remover usuários anônimos</strong>: <br>Garante que ninguém acesse o banco sem identificação.</li><li><strong>Remover banco ‘test’</strong>: <br>Apaga o banco de dados padrão que é criado na instalação e que poderia ser usado para ataques.</li></ul><pre><br>    - name: Hardening - Remover usuários anônimos<br>      mysql_user:<br>        name: &quot;&quot;<br>        state: absent<br>        login_user: root<br>        login_password: &quot;{{ db_root_password }}&quot;<br><br>    - name: Hardening - Remover banco de dados de teste<br>      mysql_db:<br>        name: test<br>        state: absent<br>        login_user: root<br>        login_password: &quot;{{ db_root_password }}&quot;</pre><h4>2.7. Liberação de Acesso via Firewall</h4><p>O RHEL é rígido com segurança de rede.</p><p>Primeiro, precisamos garantir que o serviço firewalld esteja ativo:</p><pre>    - name: Garantir que o serviço firewalld está ativo<br>      service:<br>        name: firewalld<br>        state: started<br>        enabled: yes</pre><p>Depois, usamos o módulo <strong>firewalld</strong> para abrir a porta <strong>3306</strong> (serviço MySQL).</p><p>Os parâmetros <em>permanent: yes</em> e <em>immediate: yes</em> garantem que a regra sobreviva a reinicializações e passe a valer no mesmo instante.</p><pre>    - name: Configurar Firewall (Abrir porta 3306)<br>      firewalld:<br>        service: mysql<br>        permanent: yes<br>        state: enabled<br>        immediate: yes</pre><h4>2.8. Provisionamento do Banco e Usuário da Aplicação</h4><p>O passo final é preparar o ambiente para os desenvolvedores:</p><ul><li><strong><em>mysql_db</em></strong>: <br>Cria o banco de dados específico da aplicação.</li><li><strong><em>mysql_user</em></strong>: <br>Cria o usuário da aplicação e, através do parâmetro priv, concede permissões apenas ao banco que ele deve acessar, seguindo o princípio do menor privilégio.</li></ul><pre>    - name: Criar Banco de Dados da Aplicação<br>      mysql_db:<br>        name: &quot;{{ app_db_name }}&quot;<br>        state: present<br>        login_user: root<br>        login_password: &quot;{{ db_root_password }}&quot;<br>        login_unix_socket: /var/lib/mysql/mysql.sock<br><br>    - name: Criar Usuário da Aplicação com permissões<br>      mysql_user:<br>        name: &quot;{{ app_db_user }}&quot;<br>        password: &quot;{{ app_db_password }}&quot;<br>        priv: &quot;{{ app_db_name }}.*:ALL&quot;<br>        state: present<br>        login_user: root<br>        login_password: &quot;{{ db_root_password }}&quot;<br>        login_unix_socket: /var/lib/mysql/mysql.sock</pre><p><strong>Por que usar </strong><strong>login_unix_socket: /var/lib/mysql/mysql.sock?<br></strong>No ecossistema Red Hat (RHEL/CentOS/Fedora), o uso deste parâmetro é fundamental por dois motivos:</p><ul><li><strong>Precisão do Caminho:</strong> <br>Diferente de outras distribuições Linux, o MariaDB no RHEL armazena o arquivo de comunicação local (socket) especificamente em /var/lib/mysql/mysql.sock. Sem indicar o caminho completo, o Ansible pode tentar procurar em locais padrão (como /tmp/mysql.sock) e falhar ao não encontrar o arquivo.</li><li><strong>Autenticação Local Segura:</strong> <br>O usuário root do MariaDB, por padrão, é configurado para aceitar conexões apenas via socket local. Ao definir este parâmetro, você força o Ansible a se conectar através do arquivo físico no disco, em vez de tentar uma conexão de rede (TCP/IP), garantindo que as permissões de superusuário sejam reconhecidas corretamente pelo banco de dados.</li></ul><h3>Passo 3: Entendendo a Mágica</h3><p>Neste playbook, substituímos os passos manuais por módulos inteligentes:</p><ul><li><strong><em>dnf</em></strong>: <br>Gerencia os pacotes exatamente como o comando manual, mas de forma declarativa.</li><li><strong><em>mysql_user</em> &amp; <em>mysql_db</em></strong>: <br>Estes módulos fazem o trabalho do mysql_secure_installation e da criação manual de tabelas. Eles verificam se o usuário/banco já existe antes de tentar criar.</li><li><strong>firewalld</strong>: <br>Garante que a porta 3306 esteja aberta sem que você precise decorar a sintaxe do <em>firewall-cm</em>d.</li></ul><h3>Passo 4: Execução</h3><p>Valide a sintaxe do seu arquivo:</p><pre>ansible-playbook mariadb_playbook.yml -i hosts --syntax-check</pre><p>Agora, execute o deploy:</p><pre>ansible-playbook mariadb_playbook.yml -i hosts</pre><h3>Passo 5: Verificação</h3><p>Para garantir que a automação funcionou, acesse o servidor do MariaDB a partir do seu Nó de Controle:</p><pre>ssh -i &quot;aula06-key.pem&quot; ec2-user@ec2-100-52-251-20.compute-1.amazonaws.com</pre><p>O comando acima pode ser obtido ao selecionar a instância RHEL no console da AWS, clicar no botão “Connect” e selecionar a aba “SSH client”.<br>(Tenha certeza que o chave .pem está no diretório)</p><p>Após acessar a instância RHEL, execute o comando abaixo diretamente no servidor RHEL:</p><pre>mysql -u lab_user -p lab_db</pre><p>A senha é SenhaDificil123.</p><p><strong>GITHUB:</strong><br>Crie um repositório para este projeto no GitHub e faça um push dos arquivos deste projeto para ele.</p><blockquote><strong>EVIDÊNCIA 01:<br></strong>Print do repositório GitHub mostrando o conteúdo do arquivo <em>mariadb_playbook.yml</em>.</blockquote><p><strong>DESAFIO:</strong><br>Nosso projeto está expondo a senha do MariaDB (db_root_password) em texto simples dentro de um Playbook.<br>Esta é uma falha grave de segurança.</p><p>Modifique o arquivo <em>mariadb_playbook.yml</em> para para criptografar essa informação e resolver este problema através do <strong>Ansible Vault</strong>.</p><p>Execute novamente o YAML.</p><p>Depois, faça um push do arquivo <em>mariadb_playbook.yml </em>atualizado para ele.</p><blockquote><strong>EVIDÊNCIA 02:<br></strong>Print do repositório GitHub mostrando o conteúdo do arquivo <em>mariadb_playbook.yml</em> atualizado.</blockquote><h4>Passo 6: Exclusão dos recursos</h4><p>Esse é o passo mais importante para você economizar seus créditos AWS.</p><h3>Conclusão</h3><p>Você acaba de transformar um guia de configuração manual em um ativo tecnológico replicável! Com este Playbook, o tempo de configuração caiu de 15 minutos para menos de 2 minutos, com o bônus de eliminar erros humanos.</p><p><strong>Próximos passos sugeridos:</strong></p><ul><li>Utilizar o <strong>Ansible Vault</strong> para criptografar as outras senhas.</li><li>Criar uma <strong>Role</strong> para o MariaDB para melhor organização do código.</li></ul><p><strong>Gostou desse tutorial? </strong><br>Deixe seu 👏 e compartilhe com quem está começando na jornada Cloud/DevOps! 🚀</p><p><em>Este tutorial faz parte da série “Cloud Automation Hands-on”.</em></p><p><strong>#DevOps #AWS #CloudComputing #Ansible #IaC</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1e260ffed47e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Inteligência Computacional: Implementando Memória Associativa com a Regra de Hebb em Python]]></title>
            <link>https://medium.com/@ramonriserio/intelig%C3%AAncia-computacional-implementando-mem%C3%B3ria-associativa-com-a-regra-de-hebb-em-python-7caa9ab888c5?source=rss-c0e488738463------2</link>
            <guid isPermaLink="false">https://medium.com/p/7caa9ab888c5</guid>
            <category><![CDATA[redes-neurais-artificiais]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[hebbian-theory]]></category>
            <dc:creator><![CDATA[Ramon Risério Dourado Leite]]></dc:creator>
            <pubDate>Fri, 27 Mar 2026 19:25:09 GMT</pubDate>
            <atom:updated>2026-03-27T19:25:09.619Z</atom:updated>
            <content:encoded><![CDATA[<p>Você já se perguntou como o cérebro consegue reconhecer um rosto familiar mesmo que a pessoa esteja usando óculos escuros ou esteja em um ambiente com pouca luz? Na computação, tentamos replicar essa capacidade usando as <strong>Redes Neurais de Hebb</strong>.</p><p>Neste tutorial hands-on, vamos explorar a <strong>Memória Associativa</strong>, uma técnica que permite armazenar padrões e recuperá-los mesmo quando a entrada está incompleta ou com ruído. Vamos implementar o reconhecimento da letra “A” em uma grade 5x5.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*v2bq_yFxBOXH0upw" /></figure><h3>O que é a Regra de Hebb?</h3><p>Proposta por Donald Hebb em 1949, a premissa é simples: <em>“Neurônios que disparam juntos, conectam-se juntos”</em>. Matematicamente, isso significa que se dois neurônios estão ativos ao mesmo tempo, o peso (conexão) entre eles deve ser fortalecido.</p><p>No nosso exemplo, usaremos essa regra para criar uma <strong>Matriz de Memória (M)</strong>.</p><h3>Passo 1: Preparando o Ambiente e o Padrão</h3><p>Primeiro, importamos o numpy e definimos uma função auxiliar para visualizar nossa grade 5x5. Representaremos a letra “A” usando 1 para pixels ativos e -1 para inativos.</p><blockquote><strong>Dica Técnica:</strong> <br>Usamos -1 em vez de 0 para melhorar a <strong>ortogonalidade</strong> matemática, o que ajuda a rede a distinguir melhor entre o que é “padrão” e o que é “fundo”.</blockquote><pre>import numpy as np<br><br>def exibir_grade(vetor, titulo):<br> print(f&quot;\n - - {titulo} - -&quot;)<br> grade = vetor.reshape((5, 5))<br> for linha in grade:<br> # Exibe &#39;#&#39; para pixels ativos e &#39;.&#39; para inativos<br> print(&quot; &quot;.join([&#39;#&#39; if val &gt; 0 else &#39;.&#39; for val in linha]))<br><br># Definição da letra &#39;A&#39; (Vetor 25x1)<br>letra_A = np.array([<br> -1, 1, 1, 1, -1,<br> 1, -1, -1, -1, 1,<br> 1, 1, 1, 1, 1,<br> 1, -1, -1, -1, 1,<br> 1, -1, -1, -1, 1<br>])<br><br>exibir_grade(letra_A, &quot;PADRÃO ORIGINAL: LETRA &#39;A&#39;&quot;)</pre><h3>Passo 2: Criando a Matriz de Memória (O Aprendizado)</h3><p>Para “ensinar” a rede, precisamos gerar uma matriz de correlação. Fazemos isso multiplicando o vetor do padrão por ele mesmo transposto (M = x .x^T).</p><p>Esta matriz armazena a relação entre cada pixel e todos os outros pixels da imagem.</p><pre># Transformamos o vetor em uma matriz coluna (25, 1) para o cálculo<br>vetor_coluna = letra_A.reshape(-1, 1)<br><br># Geramos a Matriz de Memória M através do produto externo<br>matriz_M = np.dot(vetor_coluna, vetor_coluna.T)<br><br>print(f&quot;Matriz de Memória M gerada com dimensões: {matriz_M.shape}&quot;)</pre><h3>Passo 3: Introduzindo Ruído (O Desafio)</h3><p>Uma memória só é útil se for resiliente. Vamos criar uma versão “corrompida” da nossa letra “A”, alterando alguns bits para simular falhas ou obstruções.</p><pre># Criamos uma cópia e &quot;limpamos&quot; alguns pixels deliberadamente<br>letra_A_com_ruido = letra_A.copy()<br>letra_A_com_ruido[0:3] = -1 # Remove o topo<br>letra_A_com_ruido[10:12] = -1 # Remove parte do meio<br><br>exibir_grade(letra_A_com_ruido, &quot;PADRÃO COM RUÍDO (ENTRADA)&quot;)</pre><h3>Passo 4: Recuperação do Padrão</h3><p>Agora vem a mágica! Para recuperar o padrão original, multiplicamos a nossa entrada com ruído pela <strong>Matriz de Memória M</strong>.</p><p>O resultado passará por uma função de ativação chamada <strong>Signum</strong>: se o valor for maior que zero, vira 1, caso contrário, vira -1.</p><pre># Produto matricial entre a entrada corrompida e a memória<br>recuperacao_bruta = np.dot(letra_A_com_ruido, matriz_M)<br><br># Aplicação da Função de Ativação (Degrau Bipolar)<br>letra_A_final = np.where(recuperacao_bruta &gt; 0, 1, -1)<br><br>exibir_grade(letra_A_final, &quot;PADRÃO RECUPERADO PELA MATRIZ&quot;)</pre><h3>Passo 5: Análise de Resultados</h3><p>Como saber se a nossa rede foi eficiente? <br>Calculamos a similaridade entre o padrão recuperado e o original.</p><pre>similaridade = np.sum(letra_A == letra_A_final) / 25 * 100<br>print(f&quot;\n[INFO] Taxa de Recuperação: {similaridade}%&quot;)</pre><p>Na maioria dos casos, mesmo com ruído significativo, a matriz consegue reconstruir os pixels ausentes baseando-se nas correlações armazenadas durante o “aprendizado”.</p><h3>Conclusão</h3><p>A Regra de Hebb é a base da neurociência computacional. Embora seja simples, ela demonstra um conceito poderoso: a informação não está guardada em um único “lugar” da matriz, mas sim na <strong>relação</strong> entre todos os seus componentes.</p><p>Este tipo de memória associativa é o precursor de modelos mais complexos, como as Redes de Hopfield, e essencial para entender como sistemas de IA modernos lidam com a reconstrução de dados.</p><p><strong>Gostou do tutorial?</strong> <br>Se você se interessa por Inteligência Computacional e Python, deixe seu comentário abaixo! 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7caa9ab888c5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ansible Playbooks: Automatizando a Configuração de um Servidor Web Nginx]]></title>
            <link>https://medium.com/@ramonriserio/ansible-playbooks-automatizando-a-configura%C3%A7%C3%A3o-de-um-servidor-web-nginx-ab0929087108?source=rss-c0e488738463------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab0929087108</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Ramon Risério Dourado Leite]]></dc:creator>
            <pubDate>Wed, 25 Mar 2026 17:59:44 GMT</pubDate>
            <atom:updated>2026-05-12T18:43:37.223Z</atom:updated>
            <content:encoded><![CDATA[<p>Se você acompanhou nossos laboratórios anteriores, já sabe como <a href="https://medium.com/@ramonriserio/primeiros-passos-com-ansible-na-aws-criando-seu-laborat%C3%B3rio-do-zero-765d1b9688ba">instalar o Ansible</a> e <a href="https://medium.com/@ramonriserio/ansible-na-pr%C3%A1tica-dominando-invent%C3%A1rios-configura%C3%A7%C3%B5es-e-comandos-ad-hoc-cd7405f0815d">executar comandos Ad-hoc</a>. Mas, no dia a dia de um DevOps, não queremos ficar digitando comandos um por um. Queremos <strong>Playbooks</strong>.</p><p>Neste hands-on, vamos estruturar um projeto Ansible completo para automatizar a configuração de um servidor Nginx no Debian. Você aprenderá a dominar o escalonamento de privilégios<strong> (<em>become</em>)</strong> e verá como os módulos <strong><em>apt</em></strong>, <strong><em>service</em></strong><em> </em>e <strong><em>copy</em></strong><em> </em>trabalham em sintonia para orquestrar um serviço robusto, padronizado e pronto para produção.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/708/0*p8e0tEuTtb33--fl.png" /></figure><h3>O que são Ansible Playbooks?</h3><p>Se os comandos Ad-Hoc são como dar ordens rápidas e isoladas para um servidor (“Ei, instale isso agora!”), os Playbooks são o plano estratégico completo.</p><p>Um Playbook é um arquivo de texto escrito em formato YAML que funciona como um “manual de instruções” ou uma “receita” para a sua infraestrutura. Nele, você descreve o estado desejado do seu ambiente — ou seja, você não diz ao Ansible como fazer cada passo técnico, mas sim o que você quer que esteja configurado ao final do processo.</p><p>Por que usar Playbooks em vez de comandos manuais?</p><p>Para um engenheiro DevOps, o uso de Playbooks traz benefícios fundamentais para a cultura de automação:</p><ul><li><strong>Infraestrutura como Código (IaC):</strong> <br>Ao escrever Playbooks, sua infraestrutura passa a ser documentada em código. Isso significa que você pode versionar suas configurações no <strong>Git</strong>, facilitando o rastreio de mudanças e o trabalho em equipe.</li><li><strong>Idempotência Garantida:</strong> <br>Um dos maiores diferenciais do Ansible. Você pode rodar o mesmo Playbook dez vezes; o Ansible só fará alterações se o servidor não estiver no estado descrito. Se o Nginx já estiver instalado e rodando, ele simplesmente ignora a tarefa, poupando tempo e evitando erros.</li><li><strong>Automação em Larga Escala:</strong> <br>Imagine configurar 50 servidores manualmente via SSH. Com um Playbook, você executa um único comando e o Ansible aplica as configurações em todos os hosts simultaneamente, garantindo que todos sejam idênticos.</li><li><strong>Legibilidade:</strong> <br>Por usar YAML, os Playbooks são fáceis de ler até por quem não é especialista em Linux. Isso diminui a curva de aprendizado e facilita auditorias de segurança.</li><li><strong>Orquestração Complexa:</strong> <br>Playbooks permitem criar fluxos lógicos. Você pode dizer: “Primeiro pare o banco de dados, depois atualize a aplicação e, por fim, reinicie o serviço”. Essa ordem cronológica é essencial para evitar <em>downtime</em>.</li></ul><h3>Pré-requisitos</h3><p>Chegou a hora de colocar a mão na massa e transformar teoria em infraestrutura real!</p><p>Para que este laboratório funcione, você precisa de:</p><ol><li><strong>Nó de Controle:</strong> Uma instância (EC2 ou local) com Ansible instalado.</li><li><strong>Nó Gerenciado:</strong> Pelo menos um servidor com <strong>Debian</strong>.</li><li><strong>Acesso SSH:</strong> Conectividade garantida entre as máquinas (chave .pem).</li><li><strong>Inventário:</strong> O arquivo hosts configurado com o IP do seu servidor alvo.</li></ol><blockquote><strong>Dica:</strong> <br>Se você caiu aqui de paraquedas e ainda não configurou seu ambiente, recomendo conferir nosso guia de <a href="https://medium.com/@ramonriserio/primeiros-passos-com-ansible-na-aws-criando-seu-laborat%C3%B3rio-do-zero-765d1b9688ba">Primeiros Passos com Ansible na AWS</a>.</blockquote><h3>Passo 1: Organizando a Casa</h3><p>No Ansible, organização é tudo. <br>Vamos criar um diretório exclusivo para este projeto.</p><p>Acesse o nó de controle e execute o seguinte comando para a criação deste diretório:</p><pre>mkdir lab_nginx &amp;&amp; cd lab_nginx</pre><p>Agora, crie o seu arquivo de inventário (se ainda não tiver um nesta pasta):</p><pre>touch hosts</pre><p>Edite o arquivo hosts e adicione o IP privado do seu servidor Debian sob o grupo [webservers]:</p><pre>[webservers] # Substitua o IP abaixo pelo IP privado do seu servidor debian e pela sua chave .pem<br>192.168.1.XX ansible_user=admin ansible_ssh_private_key_file=/home/ec2-user/lab_nginx/aula06-key.pem</pre><h3>Passo 2: Escrevendo o Playbook (nginx_setup.yml)</h3><p>Agora vem a parte divertida. Vamos criar o arquivo que contém a nossa “receita” de automação.</p><p>Crie o arquivo:</p><pre>touch nginx_setup.yml</pre><p>Abra-o no seu editor preferido (VS Code, Vim ou Nano) e cole o seguinte conteúdo:</p><pre>---<br>- name: Configuração do Servidor Web Nginx no Debian<br>  hosts: webservers<br>  become: yes     # Executa como root (sudo)<br>  tasks:</pre><pre>- name: 1. Garantir que o cache do apt esteja atualizado<br>  apt:<br>  update_cache: yes</pre><pre>- name: 2. Instalar o pacote Nginx<br>  apt:<br>  name: nginx<br>  state: latest</pre><pre>- name: 3. Garantir que o Nginx esteja rodando e habilitado no boot<br>  service:<br>  name: nginx<br>  state: started<br>  enabled: yes</pre><pre>- name: 4. Criar uma página HTML customizada<br>  copy:<br>  content: &quot;&lt;h1&gt;Servidor Nginx configurado via Ansible - Lab Finalizado!&lt;/h1&gt;&quot;<br>  dest: /var/www/html/index.html<br>  mode: &#39;0644&#39;</pre><h3>O que está acontecendo aqui?</h3><ul><li><strong>become: yes</strong>: <br>Fundamental! <br>Como estamos instalando software, precisamos de privilégios de superusuário.</li><li><strong>Módulo apt</strong>: <br>Usado para gerenciar pacotes no Debian/Ubuntu.</li><li><strong>Módulo service</strong>: <br>Garante que o serviço não apenas suba agora, mas que reinicie sozinho se o servidor for reiniciado.</li><li><strong>Módulo copy</strong>: <br>Aqui, em vez de copiar um arquivo pronto, usamos content para escrever o HTML diretamente pelo Ansible.</li></ul><h3>Passo 3: Validando a Sintaxe</h3><p>Antes de sair executando, é uma boa prática validar se o seu arquivo YAML não tem erros de indentação (o calcanhar de Aquiles de muitos DevOps iniciantes).</p><p>Execute:</p><pre>ansible-playbook nginx_setup.yml -i hosts --syntax-check</pre><p><em>Se ele apenas retornar o nome do arquivo, você está pronto para o deploy!</em></p><h3>Passo 4: Executando a Automação</h3><p>Agora, vamos ver a mágica acontecer.<br>Mas para isso a chave .pem está dentro do diretório lab_nginx.</p><pre>ansible-playbook nginx_setup.yml -i hosts</pre><p><strong>Fique de olho nas cores:</strong></p><ul><li><strong>Amarelo (Changed):</strong> <br>O Ansible fez uma alteração (instalou o pacote ou criou o arquivo).</li><li><strong>Verde (OK):</strong> <br>O item já estava no estado desejado e nada foi alterado (Idempotência).</li><li><strong>Vermelho (Failed):</strong> <br>Algo deu errado (verifique permissões ou conectividade).</li></ul><blockquote><strong>EVIDÊNCIA 01:<br></strong>Print da tela com o resultado do comando acima.</blockquote><h3>Passo 5: Verificação Final</h3><p>Após a conclusão, valide se o servidor está realmente respondendo.</p><p><strong>Via Terminal (no Nó de Controle):</strong></p><pre>curl http://&lt;IP_PRIVADO_DEBIAN&gt;</pre><blockquote><strong>EVIDÊNCIA 02:<br></strong>Print da tela com o resultado do comando acima.</blockquote><h3>Conclusão</h3><p>Parabéns! <br>Você acaba de migrar do mundo dos comandos manuais para o mundo da <strong>automação profissional</strong>. Com este Playbook, você pode configurar 1, 10 ou 1.000 servidores Nginx de forma idêntica em questão de segundos.</p><p><strong>O que aprendemos hoje:</strong></p><ul><li>Como estruturar um projeto Ansible.</li><li>A importância do escalonamento de privilégios (<em>become</em>).</li><li>Como os módulos <em>apt</em>, <em>service </em>e <em>copy </em>trabalham juntos para entregar um serviço pronto para produção.</li></ul><p><strong>Gostou desse conteúdo?</strong> <br>Não esqueça de deixar suas palmas 👏 e me seguir para mais tutoriais de DevOps e Cloud!</p><p><strong>#DevOPs # Ansible #AWS #CloudComputing #Linux</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab0929087108" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dominando o Ansible: Um Guia Prático sobre Módulos e Automação Declarativa]]></title>
            <link>https://medium.com/@ramonriserio/dominando-o-ansible-um-guia-pr%C3%A1tico-sobre-m%C3%B3dulos-e-automa%C3%A7%C3%A3o-declarativa-13025cb23aa3?source=rss-c0e488738463------2</link>
            <guid isPermaLink="false">https://medium.com/p/13025cb23aa3</guid>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Ramon Risério Dourado Leite]]></dc:creator>
            <pubDate>Sat, 21 Mar 2026 23:50:28 GMT</pubDate>
            <atom:updated>2026-03-22T01:25:34.232Z</atom:updated>
            <content:encoded><![CDATA[<p>Se você já configurou o seu inventário e conseguiu executar o famoso <em>ansible all -m ping</em>, parabéns! A comunicação está estabelecida. Mas o verdadeiro poder do Ansible não está apenas em “pingar” servidores; está no seu vasto ecossistema de <strong>Módulos</strong>.</p><p>Pense nos módulos como ferramentas em uma caixa de ferramentas. O Ansible possui centenas deles prontos para uso, abstraindo a complexidade de gerenciar pacotes, serviços, arquivos e até infraestrutura em nuvem (AWS, Azure, GCP).</p><p>Neste laboratório prático (hands-on), vamos explorar os módulos essenciais do Ansible (<em>command</em>, <em>apt</em>, <em>service</em>, <em>shell</em>, <em>copy </em>e <em>file</em>), entender a mágica da <strong>idempotência</strong> e ver na prática a diferença entre ser imperativo e ser declarativo.</p><p>Prepare seu terminal, acesse seu nó de controle e vamos lá!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*YsGpeTGIuPRfjkZM.png" /></figure><h3>Pré-requisitos</h3><p>Para acompanhar este tutorial sem interrupções, você precisará de:</p><ol><li>Uma instância EC2 atuando como <strong>Nó de Controle</strong> com o Ansible instalado e configurado.<br><em>Se você ainda não configurou seu primeiro nó de controle Ansible na AWS, você fazê-lo acessando o tutorial/hands-on </em><a href="https://medium.com/@ramonriserio/primeiros-passos-com-ansible-na-aws-criando-seu-laborat%C3%B3rio-do-zero-765d1b9688ba"><strong><em>Primeiros Passos com Ansible na AWS: Criando seu Laboratório do Zero</em></strong></a><em>.</em></li><li>Servidores gerenciados configurados no seu inventário (neste exemplo, usaremos instâncias que chamaremos de host01 e host02).<br><em>Você pode ver como incluir dois servidores gerenciados em seu inventário acessando o tutorial/hands-on </em><a href="https://medium.com/@ramonriserio/ansible-na-pr%C3%A1tica-dominando-invent%C3%A1rios-configura%C3%A7%C3%B5es-e-comandos-ad-hoc-cd7405f0815d"><strong><em>Ansible na Prática: Dominando Inventários, Configurações e Comandos Ad-Hoc</em></strong></a><em>.</em></li><li>Comunicação SSH previamente testada e funcionando entre o nó de controle e os hosts.</li></ol><h3>Passo 1: Interagindo com o Sistema (Módulo command)</h3><p>O módulo command é um dos mais básicos. Ele executa comandos diretamente no <em>shell</em> dos servidores remotos. É ótimo para verificações rápidas de estado.</p><p>No seu terminal (nó de controle), execute:</p><pre>ansible all -m command -a &#39;id&#39;</pre><h4><strong><em>Detalhando</em></strong><em>:</em></h4><p><em>-m </em>chama o módulo command<br><em>-a </em>passa os argumentos (neste caso, o comando id)<em>.</em></p><p><em>Você verá o usuário com o qual o Ansible está se conectando em cada máquina.</em></p><p>Vamos ver há quanto tempo os servidores estão ligados?</p><pre>ansible all -m command -a &#39;uptime&#39;</pre><h3>Passo 2: Gerenciamento de Pacotes e a Mágica da Idempotência (Módulos apt e yum)</h3><p>Agora vamos instalar um software. <br>Para sistemas Debian/Ubuntu, usamos o módulo <em>apt</em>. <br>Para RedHat/CentOS, usamos <em>yum</em> ou <em>dnf</em>.</p><p>Vamos tentar instalar o servidor web Nginx no host01 (assumindo que seja um Debian):</p><pre>ansible host01 -m apt -a &quot;name=nginx state=latest update_cache=yes&quot;</pre><h4><strong>Ops! Deu erro?</strong></h4><p>Provavelmente você recebeu um aviso de “<em>Permission denied</em>” (Permissão negada). Instalar pacotes requer privilégios de administrador (root).</p><p>Para resolver isso, usamos a flag <em>-b</em> (que significa <em>become</em> / <em>tornar-se</em>), instruindo o Ansible a usar o <em>sudo</em>:</p><pre>ansible host01 -m apt -a &quot;name=nginx state=latest update_cache=yes&quot; -b</pre><blockquote><strong>EVIDÊNCIA 01<br></strong>Print do resultado do comando acima.</blockquote><h4><strong>Entendendo as Cores (Idempotência)</strong></h4><p>Ao executar o comando com sucesso, a saída no terminal será <strong>Amarela (Changed)</strong>. Isso significa que o Ansible percebeu que o Nginx não estava lá e realizou uma alteração no servidor (instalou o pacote).</p><p><strong>O grande truque:</strong> Execute o exato mesmo comando novamente:</p><pre>ansible host01 -m apt -a &quot;name=nginx state=latest update_cache=yes&quot; -b</pre><p>Agora a saída será <strong>Verde (Success/OK)</strong>. <br>O Ansible verificou o servidor, viu que o Nginx já estava na versão mais recente (<em>state=latest</em>) e <strong>não fez nada</strong>.</p><p>Esse é o princípio da <strong>idempotência</strong>: <br>Você pode rodar a mesma automação 100 vezes, e o resultado final será sempre o mesmo, sem quebrar o sistema ou reinstalar coisas desnecessárias.</p><h3>Passo 3: Manipulando Arquivos (Módulos copy e file)</h3><p>Vamos criar um arquivo no nosso nó de controle e distribuí-lo para todos os servidores.</p><ol><li>Crie um arquivo de teste no seu nó de controle:</li></ol><pre>echo &quot;This is an example file&quot; &gt;&gt; dump</pre><p>2. Verifique se esse arquivo existe no diretório <em>/tmp</em> dos seus hosts <br> (vai falhar, pois ainda não o enviamos):</p><pre>ansible all -m command -a &#39;ls /tmp/dump&#39;</pre><p>3. <strong>Copiando o arquivo</strong> usando o módulo <em>copy</em>:</p><pre>ansible all -m copy -a &quot;src=dump dest=/tmp&quot;</pre><p>4. Leia o conteúdo do arquivo remotamente para confirmar:</p><pre>ansible all -m command -a &quot;cat /tmp/dump&quot;</pre><blockquote><strong>EVIDÊNCIA 02<br></strong>Print do resultado do comando acima.</blockquote><p>5. <strong>Limpando a bagunça</strong> usando o módulo <em>file</em>. <br>Queremos que esse arquivo não exista mais (<em>state=absent</em>):</p><pre>ansible all -m file -a &#39;path=/tmp/dump state=absent&#39;</pre><p>6. Tente listar novamente e veja que o arquivo foi apagado de todos os servidores com um único comando!</p><pre>ansible all -m command -a &#39;ls /tmp/dump&#39;</pre><blockquote><strong>EVIDÊNCIA 03<br></strong>Print do resultado do comando acima.</blockquote><h3>Conclusão e Limpeza</h3><p>Incrível! Você acabou de explorar o “coração” do Ansible. Módulos como <em>apt</em>, <em>service</em>, <em>copy </em>e <em>file </em>cobrem cerca de 80% das necessidades diárias de um engenheiro de infraestrutura. Compreender o comportamento declarativo e a idempotência é o que separa um executor de scripts de um verdadeiro profissional de DevOps.</p><h4><strong>Boas práticas de Cloud (Evite custos):</strong></h4><p>Como este é um ambiente de laboratório, não se esqueça de limpar sua infraestrutura!</p><ol><li>Feche sua conexão remota (SSH).</li><li>Vá até o console da AWS (EC2) e encerre (<strong>Terminate</strong>) as instâncias host01 e host02.</li><li>Pare (<strong>Stop</strong>) a sua instância do Nó de Controle, caso vá utilizá-la em laboratórios futuros.</li><li>Clique em <strong><em>End Lab</em></strong> no AWS Academy Learner Lab.</li></ol><p>Gostou do tutorial? Deixe suas palmas 👏 e compartilhe com sua rede! No próximo artigo, daremos um passo além e transformaremos esses comandos ad-hoc em poderosos <strong>Playbooks</strong> YAML. Até lá!</p><p><strong>#DevOps #Ansible #AWS #Cloud #SysAdmin</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=13025cb23aa3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ansible na Prática: Dominando Inventários, Configurações e Comandos Ad-Hoc]]></title>
            <link>https://medium.com/@ramonriserio/ansible-na-pr%C3%A1tica-dominando-invent%C3%A1rios-configura%C3%A7%C3%B5es-e-comandos-ad-hoc-cd7405f0815d?source=rss-c0e488738463------2</link>
            <guid isPermaLink="false">https://medium.com/p/cd7405f0815d</guid>
            <category><![CDATA[sysadmin]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Ramon Risério Dourado Leite]]></dc:creator>
            <pubDate>Fri, 20 Mar 2026 01:03:11 GMT</pubDate>
            <atom:updated>2026-03-22T00:09:12.966Z</atom:updated>
            <content:encoded><![CDATA[<p>Se você já configurou o seu primeiro nó de controle Ansible na AWS, parabéns! Você deu o primeiro passo na jornada da automação. Mas como o Ansible sabe <em>quem</em> ele deve gerenciar e <em>como</em> se conectar a esses servidores?</p><p>Neste laboratório prático (hands-on), vamos desmistificar três pilares fundamentais do Ansible: o <strong>Arquivo de Inventário</strong>, os <strong>Comandos Ad-Hoc</strong> e o <strong>Arquivo de Configuração (ansible.cfg)</strong>.</p><p>Prepare seu terminal, acesse sua instância EC2 (nó de controle) e vamos colocar a mão na massa!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/996/1*9xO4758o6arnq3R-CNC5_Q.png" /></figure><blockquote><strong>Atenção!</strong><br>Se você ainda não configurou seu primeiro nó de controle Ansible na AWS, você fazê-lo acessando o tutorial/hands-on <a href="https://medium.com/@ramonriserio/primeiros-passos-com-ansible-na-aws-criando-seu-laborat%C3%B3rio-do-zero-765d1b9688ba">Primeiros Passos com Ansible na AWS: Criando seu Laboratório do Zero</a>.</blockquote><h3>Pré-requisitos</h3><p>Para acompanhar este tutorial, assumimos que você já possui:</p><ol><li>Uma instância EC2 atuando como <strong>Nó de Controle</strong> com o Ansible instalado.</li><li>Duas instâncias EC2 que atuarão como <strong>servidores</strong>.<br>(host01 rodando Debian e host02 rodando RHEL)</li><li>A chave SSH (<em>aula06-key.pem</em>) salva no seu nó de controle para permitir a conexão com os hosts.</li></ol><h3>Passo 1: Criando o Arquivo de Inventário</h3><p>O arquivo de inventário é basicamente a “lista de contatos” do Ansible. <br>É nele que dizemos quais são os IPs dos servidores que queremos gerenciar.</p><ol><li>No terminal do seu nó de controle, crie uma pasta para organizar nossas tarefas e entre nela:</li></ol><pre>mkdir ansible-tasks &amp;&amp; cd ansible-tasks</pre><p>2. Crie um arquivo chamado hosts:</p><pre>touch hosts</pre><p>3. Edite o arquivo (usando nano ou vim) e insira os <strong>IPs Privados</strong> das suas instâncias host01 e host02. Seu arquivo deve ficar parecido com isso:</p><pre>172.31.x.x   # Substitua pelo IP Privado do host01 (Debian)<br>172.31.y.y   # Substitua pelo IP Privado do host02 (RHEL)</pre><h3>Passo 2: Testando a Comunicação com Comandos “Ad-Hoc”</h3><p>Comandos <em>Ad-Hoc</em> são execuções rápidas e pontuais no Ansible. <br>Usamos a própria linha de comando (sem precisar escrever um longo arquivo YAML) para realizar tarefas simples, como verificar se os servidores estão respondendo.</p><p>Vamos usar o módulo ping para testar a conectividade:</p><pre>ansible -i hosts all -m ping</pre><p><strong><em>Detalhando o comando</em></strong><em>: <br></em><strong><em>-i hosts</em></strong><em>: aponta para o nosso inventário<br></em><strong><em>all:</em></strong><em> diz para rodar em todos os servidores da lista<br></em><strong><em>-m ping:</em></strong><em> chama o módulo de teste de conexão.</em></p><p><strong>⚠️ Opa, deu erro de permissão (Permission denied)?<br></strong>Isso é perfeitamente normal! O Ansible tentou se conectar via SSH, mas nós não informamos qual chave usar, nem qual o usuário de login. Vamos corrigir isso.</p><ol><li>Primeiro, mova sua chave SSH para a pasta atual (caso ela esteja no diretório anterior):</li></ol><pre>mv ~/aula06-key.pem .</pre><p>2. Agora, vamos rodar o comando informando a chave SSH através de uma variável extra (-e):</p><pre>ansible -i hosts all -m ping -e &quot;ansible_ssh_private_key_file=aula06-key.pem&quot;</pre><p>Você notará que a conexão pode funcionar para o <strong>RHEL </strong>(pois o usuário padrão do nó de controle é <strong>ec2-user</strong>), mas falhará para o <strong>Debian</strong> (que usa o usuário <strong>admin</strong>). No próximo passo, vamos organizar o inventário para resolver isso de forma elegante.</p><h3>Passo 3: Organizando o Inventário com Grupos e Variáveis</h3><p>Para não termos que digitar usuários e chaves toda vez que rodarmos um comando, podemos declarar essas informações direto no arquivo de inventário e agrupar nossos servidores.</p><p>Edite seu arquivo hosts para deixá-lo assim (<em>lembre-se de substituir os IPs privados correspondentes</em>):</p><pre>[webservers]<br>host01 ansible_host=&lt;IP_PRIVADO_HOST01&gt; ansible_user=admin ansible_ssh_private_key_file=aula06-key.pem<br>host02 ansible_host=&lt;IP_PRIVADO_HOST02&gt; ansible_user=ec2-user ansible_ssh_private_key_file=aula06-key.pem</pre><p><strong><em>O que fizemos?</em></strong><em> <br>Criamos um grupo chamado [webservers] e definimos variáveis específicas (IP, usuário e chave) para cada host.</em></p><p>Agora, teste o ping chamando apenas o grupo webservers:</p><pre>ansible -i hosts webservers -m ping</pre><p><strong>Sucesso verde na tela!</strong> <br>O Ansible se conectou a ambos os servidores usando os usuários corretos.</p><blockquote><strong>EVIDÊNCIA 01:</strong><br>Print da tela com as mensagens de sucesso.</blockquote><h3>Passo 4: O Poder do Arquivo de Configuração (ansible.cfg)</h3><p>O comando anterior funcionou perfeitamente, mas ter que digitar -i hosts (para informar o inventário) e -m ping (para o módulo) toda vez é cansativo. Podemos otimizar isso criando um arquivo de configuração local.</p><ol><li>Verifique como o Ansible está configurado atualmente:</li></ol><pre>ansible-config view # Provavelmente retornará erro dizendo que não há arquivo<br>ansible - version # Verifique a linha &quot;config file = None&quot;</pre><p>2. Crie um arquivo <em>ansible.cfg</em> vazio na sua pasta atual:</p><pre>touch ansible.cfg</pre><p>3. Abra o arquivo <em>ansible.cfg</em> e adicione as seguintes configurações padrão (defaults):</p><pre>[defaults]<br># Desativa avisos de depreciação para manter a saída do terminal limpa<br>deprecation_warnings = False<br># Define o módulo &#39;ping&#39; como padrão<br>module_name = ping<br># Define o caminho padrão do seu inventário<br>inventory = /home/ec2-user/ansible-tasks/hosts</pre><blockquote><strong>EVIDÊNCIA 02:<br></strong>Print da tela do comando <em>ansible-config view</em> após a criação do arquivo <em>ansible.cfg</em>.</blockquote><p><strong>4. A Mágica Acontecendo:</strong><br>Agora que o Ansible sabe onde está o inventário e qual é o módulo padrão, veja como seus comandos ad-hoc ficam extremamente enxutos.<br>Para pingar todos os servidores, basta digitar:</p><pre>ansible all</pre><p>Para pingar apenas o grupo webservers:</p><pre>ansible webservers</pre><blockquote><strong>EVIDÊNCIA 03:<br></strong>Print da tela do resultado do comando ansible webservers.</blockquote><p><strong>5. Explore as configurações ativas:</strong><br>O comando dump mostra todas as configurações do Ansible. <br>Use a flag <em>--only-changed</em> para ver exatamente (em amarelo) o que o seu novo arquivo <em>ansible.cfg</em> alterou no comportamento padrão:</p><pre>ansible-config dump --only-changed</pre><blockquote><strong>EVIDÊNCIA 04:<br></strong>Print da tela do resultado do comando acima.</blockquote><h3>Conclusão e Limpeza</h3><p>Incrível, não é? Neste laboratório, você evoluiu de comandos complexos e suscetíveis a erros para uma estrutura limpa e altamente configurável. Você aprendeu a criar grupos de inventário, injetar variáveis de SSH e simplificar execuções usando o <em>ansible.cfg</em>.</p><p>Estes são os fundamentos que permitirão que você crie <em>Playbooks</em> poderosos no futuro.</p><h4><strong>Boas práticas de Cloud (Evite custos):</strong></h4><p>Ao finalizar seus estudos de hoje, não se esqueça de fechar sua conexão remota e <strong>parar (Stop)</strong> suas instâncias EC2 na AWS (Nó de controle, host01 e host02) e clicar em <strong><em>End Lab</em></strong> na AWS Academy.<br>(Mas antes você pode enviar os arquivos <strong><em>hosts</em></strong> e <strong><em>ansible.cfg</em></strong><em> </em>para seu repositório do <strong><em>GitHub</em></strong>)</p><p>Gostou do tutorial? Deixe suas palmas 👏 e compartilhe com aquele colega que está iniciando em DevOps! Se tiver dúvidas, os comentários estão abertos. Até a próxima automação! <a href="https://medium.com/%40ramonriserio/dominando-o-ansible-um-guia-pr%C3%A1tico-sobre-m%C3%B3dulos-e-automa%C3%A7%C3%A3o-declarativa-13025cb23aa3">Dominando o Ansible: Um Guia Prático sobre Módulos e Automação Declarativa</a></p><p><strong>#DevOps #Ansible #SysAdmin #AWS #Cloud</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cd7405f0815d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Primeiros Passos com Ansible na AWS: Criando seu Laboratório do Zero]]></title>
            <link>https://medium.com/@ramonriserio/primeiros-passos-com-ansible-na-aws-criando-seu-laborat%C3%B3rio-do-zero-765d1b9688ba?source=rss-c0e488738463------2</link>
            <guid isPermaLink="false">https://medium.com/p/765d1b9688ba</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[ansible]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[infrastructure-as-code]]></category>
            <dc:creator><![CDATA[Ramon Risério Dourado Leite]]></dc:creator>
            <pubDate>Thu, 19 Mar 2026 23:54:57 GMT</pubDate>
            <atom:updated>2026-03-22T00:26:37.228Z</atom:updated>
            <content:encoded><![CDATA[<p>Se você está mergulhando no mundo de DevOps, já deve saber que a automação é a chave para o sucesso. Neste laboratório prático, instalaremos o Ansible em uma instância EC2 que atuará como nó de controle e estabeleceremos conexão com dois servidores. No próximo laboratório prático (<a href="https://medium.com/%40ramonriserio/ansible-na-pr%C3%A1tica-dominando-invent%C3%A1rios-configura%C3%A7%C3%B5es-e-comandos-ad-hoc-cd7405f0815d">Ansible na Prática: Dominando Inventários, Configurações e Comandos Ad-Hoc</a>), estes servidores serão configurados como inventário para execução de tarefas automatizadas.</p><p>Vamos preparar nosso ambiente, instalar as ferramentas necessárias e garantir que nossa infraestrutura se comunique com segurança. Abra seu terminal e vamos lá!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/711/0*koVsr7zPoRzBUUm2.png" /></figure><h3>Passo 1: Pré-requisitos e Preparação do Ambiente</h3><p>Para começar, precisaremos preparar nossa conta e credenciais:</p><ol><li>Acesse o seu curso na AWS Academy e inicie o Learner Lab. <br>Aguarde o círculo ao lado de “AWS” ficar verde e clique nele para abrir o Console da AWS.</li><li>No topo do Console (barra superior direita), clique no ícone do CloudShell [&gt;_].</li><li>No terminal do CloudShell, crie o arquivo de credenciais e instale o Terraform (<strong>conforme visto na prática anterior</strong>).</li><li>Na barra de pesquisa do Console da AWS, pesquise por “Key pairs”. <br>Clique em “Criar par de chaves” e dê o nome <em>aula06-key</em>. <br>Salve o arquivo <em>aula06-key.pem.</em></li></ol><h3>Passo 2: Criação do Nó de Controle e dos Servidores</h3><p>Agora, vamos criar o nó de controle e os servidores que serão gerenciados pelo Ansible. Você precisará criar 03 instâncias AWS EC2 (todas do tipo t2.micro e na VPC Default) usando a chave que acabamos de criar.</p><p>A distribuição das máquinas será a seguinte:</p><ul><li><strong>Nó de controle:</strong> <br>Use a distribuição Amazon Linux 2023. <br>O usuário padrão será ec2-user e o gerenciador de pacotes é o yum.</li><li><strong>Servidor 1 (host01):</strong> <br>Use a distribuição Debian 12. <br>O usuário padrão será admin e o gerenciador de pacotes é o apt.</li><li><strong>Servidor 2 (host02):</strong> <br>Use a distribuição Red Hat Enterprise Linux 9 (RHEL). <br>O usuário padrão será ec2-user e o gerenciador de pacotes é o yum.</li></ul><p>Para agilizar, provisionaremos tudo via Terraform. O código abaixo cria as máquinas e um Security Group permitindo acesso SSH (porta 22). Crie um arquivo <strong>main.tf</strong> com o seguinte conteúdo:</p><pre># 1. Configuração do Provider<br>provider &quot;aws&quot; { <br> region = &quot;us-east-1&quot;<br>}<br><br># 2. Busca pela AMI do Debian 12 (Oficial)<br>data &quot;aws_ami&quot; &quot;debian_12&quot; { <br> most_recent = true <br> owners = [&quot;136693071363&quot;] <br> filter { <br>   name = &quot;name&quot; <br>   values = [&quot;debian-12-amd64-*&quot;] <br> }<br>}<br><br># 3. Busca pela AMI do RHEL 9 (Oficial)<br>data &quot;aws_ami&quot; &quot;rhel_9&quot; { <br> most_recent = true <br> owners = [&quot;309956199498&quot;] <br> filter { <br>   name = &quot;name&quot; <br>   values = [&quot;RHEL-9.2.0_HVM-*-x86_64-*&quot;] <br> }<br>}<br><br># 4. Criar Security Group (SSH Aberto)<br>resource &quot;aws_security_group&quot; &quot;ssh_access&quot; { <br> name = &quot;aula06-ansible&quot; <br> description = &quot;Permitir SSH para aula de Ansible&quot;<br> # REGRA 1: Permite qualquer um acessar as instâncias via SSH <br> ingress { <br>   from_port = 22 <br>   to_port = 22 <br>   protocol = &quot;tcp&quot; <br>   cidr_blocks = [&quot;0.0.0.0/0&quot;] <br> } <br> <br> egress { <br>   from_port = 0 <br>   to_port = 0 <br>   protocol = &quot;-1&quot; <br>   cidr_blocks = [&quot;0.0.0.0/0&quot;] <br> }<br>}<br><br># 5. Instância 1: host01 (Debian 12)<br>resource &quot;aws_instance&quot; &quot;host01&quot; { <br> ami = data.aws_ami.debian_12.id <br> instance_type = &quot;t2.micro&quot; <br> key_name = &quot;aula06-key&quot; <br> vpc_security_group_ids = [aws_security_group.ssh_access.id] <br> tags = { Name = &quot;host01-debian&quot; }<br>}<br><br># 6. Instância 2: host02 (RHEL 9)<br>resource &quot;aws_instance&quot; &quot;host02&quot; { <br> ami = data.aws_ami.rhel_9.id <br> instance_type = &quot;t2.micro&quot; <br> key_name = &quot;aula06-key&quot; <br> vpc_security_group_ids = [aws_security_group.ssh_access.id] <br> tags = { Name = &quot;host02-rhel&quot; }<br>} <br><br># 7. Nó de controle<br>resource &quot;aws_instance&quot; &quot;no_controle&quot; { <br> ami = &quot;ami-0440d3b780d96b29d&quot; <br> instance_type = &quot;t2.micro&quot; <br> key_name = &quot;aula06-key&quot; <br> vpc_security_group_ids = [aws_security_group.ssh_access.id]<br> tags = { Name = &quot;no-controle-ansible&quot; }<br>} <br><br># 8. Outputs para facilitar o inventário do Ansible<br>output &quot;ip_host01_debian&quot; { value = aws_instance.host01.private_ip }<br>output &quot;ip_host02_rhel&quot; { value = aws_instance.host02.private_ip }<br>output &quot;ip_no_controle&quot; { value = aws_instance.no_controle.private_ip }hcl</pre><p>Aplique a infraestrutura executando os comandos em sequência:</p><pre>terraform init<br>terraform plan <br>terraform apply</pre><p>Após a finalização, <strong>salve os IPs das 3 instâncias</strong> que aparecerão no output.</p><blockquote><strong>EVIDÊNCIA 01:</strong><br>Print da tela com os outputs resultantes do <em>terraform apply</em>.</blockquote><h3>Passo 3: Instalando Ansible no Nó de Controle</h3><p>Acesse o nó de controle via SSH para instalarmos as dependências.</p><p><strong>Um detalhe interessante</strong>: <br>O Ansible foi desenvolvido em Python! Seu núcleo e módulos são escritos em Python, e tanto o nó de controle quanto os hosts gerenciados geralmente precisam ter o Python instalado. No entanto, os playbooks são escritos em YAML, então não é necessário saber Python para usar o Ansible.</p><p>Execute os comandos abaixo para verificar se o Python, o PIP (gerenciador de pacotes do Python) e o próprio Ansible já estão instalados:</p><pre>python3 --version<br>pip3 --version<br>ansible --version</pre><p>Caso seja necessário, atualize o sistema operacional e instale o Python e o PIP:</p><pre>sudo yum update -y<br>sudo yum install python -y<br>sudo yum install pip -y</pre><p>Em seguida, instale o Ansible utilizando o PIP:</p><pre>python3 -m pip install --user ansible</pre><p>Valide a instalação verificando a versão novamente com <em>ansible — version</em>.</p><h3>Passo 4: Testando Comunicação via Ping e Ajustando Regras</h3><p>Este teste é essencial antes de executar tarefas com o Ansible, pois garante que a conectividade entre o nó de controle e os hosts gerenciados está funcionando corretamente, evitando falhas durante a automação.</p><p>Em seu nó de controle, tente “pingar” os IPs privados das instâncias que criamos (<strong>Você copiou estes IPs = saídas do output do Terraform. Substitua-os nos comandos abaixo</strong>):</p><pre>ping PRIVATE-IP_host01 -c3<br>ping PRIVATE-IP_host02 -c3</pre><p><strong>Você notará que o comando falha.</strong><br>Isso acontece porque precisamos permitir o tráfego de ping dentro do nosso Security Group. Para resolver a falha de comunicação, permita que todo o tráfego flua dentro do próprio Security Group. Esta ação permite que o nó de controle e os Hosts Gerenciados (host01 e host02) possam se comunicar!</p><ul><li><strong>Mas por que fazer assim e não liberar por IP?</strong> <br><strong>IP Dinâmico:</strong> <br>Se a sua IDE ou EC2 for reiniciada e o IP mudar, a regra continua funcionando, pois o “ID do Grupo” não muda.<br><strong>Escalabilidade:</strong> <br>Se você criar 10 novas IDEs e colocá-las no mesmo grupo de segurança, todas já terão acesso automático aos hosts, sem você precisar cadastrar 10 IPs novos.</li></ul><p>Para fazer isso no Terraform, inclua a regra abaixo no seu resource <em>aws_security_group</em> “ssh_access”:</p><pre> # REGRA 2: Permite que as máquinas falem entre si (Interno)<br> # Isso permite que o nóde de controle (se estiver neste SG) acesse os Hosts<br> ingress {<br>   from_port = 0<br>   to_port = 0<br>   protocol = &quot;-1&quot;   # Todos os protocolos<br>   self = true       # FUNDAMENTAL: permite tráfego entre instâncias do MESMO grupo<br> }</pre><p>Aplique o código do Terraform atualizado, volte ao terminal e teste novamente:</p><pre>ping PRIVATE-IP_host01 -c3<br>ping PRIVATE-IP_host02 -c3</pre><p>Agora o ping deve responder com sucesso!</p><h3>Passo 5: Teste de Conexão SSH</h3><p>Para que o Ansible execute comandos na infraestrutura, precisamos garantir o acesso SSH.</p><p>Primeiro, faça o upload da chave SSH (<em>aula06-key.pem</em>) para o nó de controle, colocando-a dentro do diretório <em>/home/ec2-user</em>. No prompt de comando da sua máquina (ex: Windows), execute o comando abaixo:</p><pre>scp -i &quot;&lt;CAMINHO&gt;\aula06-key.pem&quot; &quot;aula06-key.pem&quot; ec2-user@&lt;IP PÚBLICO&gt;:/home/ec2-user</pre><p>No terminal do nó de controle, tente conectar no host01 com o IP privado:</p><pre>ssh -i aula06-key.pem admin@&lt;PRIVATE-IP_host01&gt;</pre><p>Você notará que haverá um erro pois a permissão do arquivo da chave está incorreta. Este é um problema comum do qual você precisa estar ciente. Altere as permissões do arquivo da chave e tente novamente:</p><pre>ls -l aula06-key.pem<br>chmod 400 aula06-key.pem<br>ls -l aula06-key.pem</pre><p>Agora, faça o login no <strong>host01 (Debian)</strong> e verifique o sistema:</p><pre>ssh -i aula06-key.pem admin@&lt;PRIVATE-IP_host01&gt;<br>cat /etc/*rel*</pre><p>Faça o mesmo teste para o <strong>host02 (RHEL)</strong>, lembrando de usar o usuário correto:</p><pre>ssh -i aula06-key.pem ec2-user@&lt;PRIVATE-IP_host02&gt;<br>cat /etc/*rel*</pre><blockquote><strong>EVIDÊNCIA 02:<br></strong>Print da tela mostrando a conexão com o host01 e com o host02.</blockquote><h3>Conclusão e Limpeza</h3><p>Parabéns! Seu nó de controle agora consegue se comunicar perfeitamente com seu inventário de instâncias via rede e SSH. Você construiu a fundação necessária para começar a escrever e executar seus primeiros playbooks em YAML.</p><p>Agora, para seu próximo passo no mundo Ansible, acesse <a href="https://medium.com/@ramonriserio/ansible-na-pr%C3%A1tica-dominando-invent%C3%A1rios-configura%C3%A7%C3%B5es-e-comandos-ad-hoc-cd7405f0815d">Ansible na Prática: Dominando Inventários, Configurações e Comandos Ad-Hoc</a>.</p><p>Boas práticas de encerramento do laboratório:</p><ol><li>Crie um repositório no GitHub e faça um push de seu arquivo main.tf para guardar como portfólio.</li><li>Se você for demorar para fazer o próximo hands-on, para evitar custos indesejados na sua conta AWS após este laboratório, clique em <strong>End Lab</strong>.</li></ol><p><strong>#DevOps #Ansible #AWS #Terraform #IaC</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=765d1b9688ba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Do Caos à Colaboração: 
Git Avançado para times de alta Performance]]></title>
            <link>https://medium.com/@ramonriserio/do-caos-%C3%A0-colabora%C3%A7%C3%A3o-git-avan%C3%A7ado-para-times-de-alta-performance-578c7d401fef?source=rss-c0e488738463------2</link>
            <guid isPermaLink="false">https://medium.com/p/578c7d401fef</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[git]]></category>
            <dc:creator><![CDATA[Ramon Risério Dourado Leite]]></dc:creator>
            <pubDate>Thu, 05 Mar 2026 15:18:11 GMT</pubDate>
            <atom:updated>2026-03-08T14:45:32.738Z</atom:updated>
            <content:encoded><![CDATA[<h4>Mais do que commits e pushes: aprenda a manter histórico limpo, evitar conflitos e garantir segurança em ambientes de alta performance.</h4><p>No dia a dia de um <strong>DevOps</strong>, o código não é apenas sobre aplicações; é sobre infraestrutura, pipelines e automação. Por isso, dominar o Git vai muito além do git commit e git push. Se você quer trabalhar em equipe sem quebrar a main, precisa entender o fluxo de trabalho profissional.</p><p>Neste guia prático, vamos simular uma colaboração real entre dois profissionais (<strong>DevOps A</strong> e <strong>DevOps B</strong>) para resolver conflitos e manter um histórico de commits limpo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SotOJ2CgDSD0Tkuc" /></figure><h3>1. Introdução: <br>Por que o Git Avançado é Vital no DevOps?</h3><p>No ecossistema de Nuvem, a prática de <strong>Infrastructure as Code (IaC)</strong> exige rigor no controle de versão. Pequenos erros podem resultar em deploys indevidos ou até mesmo na sobrescrição de configurações críticas de segurança. Por isso, estratégias como <strong>Gitflow</strong> e <strong>Conventional Commits</strong> são fundamentais: elas permitem que a equipe saiba exatamente o que foi alterado, por quem e com qual propósito.</p><p>Essa necessidade de organização mostra que o Git vai muito além de simplesmente “salvar” arquivos. No contexto do <strong>DevOps</strong> e do desenvolvimento colaborativo, ele é a ferramenta que garante que várias pessoas possam trabalhar no mesmo projeto sem gerar caos. É nesse ponto que entram práticas como <strong>Pull Requests</strong> e <strong>Merge</strong>, que funcionam como mecanismos de coordenação e validação das mudanças.</p><p>Para visualizar melhor, pense no repositório principal como uma rodovia movimentada — a branch <em>main</em>. Não é possível interromper o tráfego para realizar obras diretamente nela. Em vez disso, cria-se um desvio (uma branch), onde o trabalho é feito de forma isolada. Somente após a conclusão, solicita-se permissão para reintegrar esse desvio à rodovia principal, garantindo que o fluxo continue seguro e organizado.</p><h3>1. O que é Pull Request (PR)?</h3><p>O <strong>Pull Request</strong> não é um comando do Git, mas uma funcionalidade de plataformas como GitHub, GitLab e Bitbucket. É, essencialmente, um <strong>pedido de revisão</strong>.</p><ul><li><strong>O que ele faz:</strong> Ele avisa aos seus colegas (como o DevOps A) que você concluiu uma tarefa em uma branch separada e gostaria que esse código fosse revisado e, eventualmente, somado ao projeto principal.</li><li><strong>A analogia:</strong> É como um autor enviando um capítulo de um livro para o editor. O capítulo está pronto, mas ainda não foi impresso na versão final do livro.</li></ul><h3>2. O que é Merge?</h3><p>O <strong>Merge</strong> (mesclar) é o ato técnico de unir duas histórias diferentes. É o comando que pega os commits de uma branch (ex: feature/perfil-usuario) e os aplica na branch de destino (ex: develop).</p><ul><li><strong>O que ele faz:</strong> <br>Ele consolida as alterações. Uma vez que o merge é concluído, o histórico das duas branches se torna um só.</li><li><strong>A analogia:</strong> <br>É o momento em que o editor aceita o capítulo do autor e o cola oficialmente no manuscrito original.</li></ul><h3>3. Em qual situação ocorrem?</h3><p>O fluxo padrão em uma equipe DevOps segue esta ordem:</p><ol><li><strong>Criação da Branch:</strong> <br>Você sai da develop para trabalhar isolado.</li><li><strong>Desenvolvimento:</strong> <br>Você faz seus commits.</li><li><strong>Abertura do Pull Request:</strong> <br>Você terminou a tarefa e abre o PR no GitHub para que a equipe veja o que você fez.</li><li><strong>Code Review:</strong> <br>Seus colegas comentam e aprovam o PR.</li><li><strong>Merge:</strong> <br>Após a aprovação, o botão de Merge é clicado, e seu código finalmente “entra” na branch principal da equipe.</li></ol><h3>4. Por que são importantes?</h3><h4>Segurança e Estabilidade</h4><p>O PR funciona como uma <strong>barreira de segurança</strong>. Se você cometer um erro de sintaxe em um arquivo do Kubernetes ou Terraform, o revisor pode detectar isso no PR antes que o erro chegue ao ambiente de produção e cause um “down” no sistema.</p><h4>Qualidade de Código (Code Review)</h4><p>Ninguém sabe tudo. O PR permite que o <strong>DevOps A</strong> sugira uma forma mais performática de escrever um script que o <strong>DevOps B</strong> criou. Isso dissemina o conhecimento técnico por toda a equipe.</p><h4>Histórico e Documentação</h4><p>O PR mantém um registro de <strong>por que</strong> aquela mudança foi feita. Se daqui a seis meses algo quebrar, você pode voltar no Pull Request e ler toda a discussão técnica que levou àquela decisão.</p><h4>Trabalho em Equipe Paralelo</h4><p>Sem PRs e Merges, apenas uma pessoa poderia mexer no código por vez. Com eles, dez engenheiros podem trabalhar em dez funcionalidades diferentes simultaneamente e depois integrar tudo de forma organizada.</p><h3>2. Pré-requisitos</h3><p>Para seguir este hands-on, você e um colega (ou você usando duas pastas diferentes) precisarão de:</p><ul><li>Contas ativas no <strong>GitHub</strong>.</li><li><strong>Git</strong> instalado localmente.</li><li><strong>VS Code</strong> (ou seu editor de preferência) para resolução de conflitos.</li></ul><p>Para que seus commits no GitHub apareçam com o seu nome e seu email corretamente, você precisa configurar o Git na sua máquina local. Sem isso, o Git usará o nome de usuário do seu sistema operacional, o que não é nada profissional para um <strong>DevOps</strong>.</p><p>Aqui está o passo a passo para configurar as suas credenciais:</p><h4>2.1. Configuração Global</h4><p>Abra o seu terminal (ou Git Bash) e execute os seguintes comandos, substituindo pelos seus dados:</p><pre># Define seu nome (aparecerá nos logs de commit)<br>git config --global user.name &quot;Seu Nome Completo&quot;<br># Define seu e-mail (deve ser o mesmo e-mail da sua conta GitHub)<br>git config --global user.email &quot;seuemail@exemplo.com&quot;</pre><h4>2.2. Como verificar se deu certo?</h4><p>Para confirmar que as informações foram gravadas corretamente, execute:</p><pre>git config --list</pre><h3>3. Passo a Passo Prático: O Fluxo de Trabalho</h3><h3>Fase 1: Setup do Ambiente (DevOps A)</h3><p>O <strong>DevOps A</strong> prepara o terreno criando o repositório centralizado:</p><ol><li>Crie um repositório público chamado lab-git-avancado no GitHub:</li></ol><ul><li>No canto superior direito de qualquer página do GitHub, clique no ícone <strong>“+”</strong> e selecione <strong>“New repository”</strong>.</li><li>Em <strong>Repository name</strong>, digite lab-git-avancado.</li><li>Certifique-se de que a opção <strong>Public</strong> está selecionada.</li></ul><blockquote><strong>Importante:</strong> <br>Não marque a opção de adicionar um arquivo README ou .gitignore agora, para que o repositório comece totalmente vazio.</blockquote><ul><li>Clique no botão verde <strong>“Create repository”</strong>.</li></ul><p>2. Adicione o <strong>DevOps B</strong> como colaborador em <strong>Settings &gt; Collaborators</strong>.<br><em>(o DevOps B precisa ter uma conta no Github)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hALXB3WO05xJeg1MIWMniQ.png" /></figure><p>3.<strong> Proteção de Branch:</strong> <br>Configure um <em>Ruleset</em> para a branch main exigindo um Pull Request antes do merge e bloqueando <em>force pushes</em>:</p><ul><li>O DevOps A vai em <strong>Settings</strong> &gt; <strong>Rules</strong> &gt; <strong>Rulesets</strong>.</li><li>Clique em <strong>New ruleset</strong> &gt; <strong>New branch ruleset</strong>.</li><li><strong>Ruleset Name:</strong> Proteção da Main.</li><li><strong>Enforcement status:</strong> Mude para <strong>Active</strong>.</li><li><strong>Target branches:</strong> Clique em <strong>Add target</strong> &gt; <strong>Include default branch</strong> <br>(para proteger a main).</li><li><strong>Branch rules:</strong> Marque a caixa <strong>Require a pull request before merging</strong>.</li><li><strong>Block force pushes:</strong> Marque esta opção para evitar sobrescritas acidentais na branch principal.</li><li>Clique em <strong>Create</strong> no final da página.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dKYz9MYv-jZGhzbb7Pbsxw.png" /></figure><ol><li><strong>Criar a Develop:</strong> O DevOps A cria a branch de desenvolvimento a partir da main e dá push:</li></ol><pre>git checkout -b develop<br>git push origin develop</pre><h3>Fase 1.1: Aceitando o Convite (DevOps B)</h3><p>Para que o <strong>DevOps B</strong> consiga interagir com o repositório, ele deve seguir estes passos:</p><ol><li><strong>Aceder ao Email:</strong> O <strong>DevOps B</strong> deve abrir a caixa de entrada do email associado à sua conta do GitHub.</li><li><strong>Localizar o Convite:</strong> Procure por um email enviado pelo GitHub com o assunto <em>“DevOps A invited you to collaborate on lab-git-avancado”</em>.</li><li><strong>Visualizar Convite:</strong> Clique no botão verde <strong>“View Invitation”</strong> dentro do corpo do email.</li><li><strong>Aceitar no GitHub:</strong> Você será redirecionado para uma página do GitHub. Clique no botão <strong>“Accept invitation”</strong> para confirmar a sua entrada como colaborador.</li></ol><blockquote><strong><em>Dica:</em></strong> <br>Caso não encontre o email, o <strong>DevOps B</strong> pode aceder diretamente ao link do repositório criado pelo <strong>DevOps A</strong> e verá um banner no topo da página convidando-o a aceitar a colaboração.</blockquote><h3>Fase 2: Desenvolvimento em Paralelo</h3><p>Ambos clonam o repositório:</p><p>git clone &lt;URL_DO_REPOSITORIO_GITHUB&gt;</p><p>cd lab-git-avancado</p><ol><li><strong>DevOps B:</strong> <br>Cria a branch feature/perfil-usuario a partir da develop, cria um arquivo perfil.txt com seu nome e envia para o servidor:</li></ol><ul><li>Cria uma branch: git checkout -b feature/perfil-usuario (partindo da develop).</li><li>Cria um arquivo perfil.txt e escreve seu nome.</li><li>Faz o commit: git add . e git commit -m “feat: adiciona arquivo de perfil do DevOps B”.</li><li>Envia para o GitHub: git push origin feature/perfil-usuario.</li></ul><p><strong>2. DevOps A:</strong> <br>Cria a branch feature/configuracao, cria um arquivo config.txt <strong>e também um arquivo perfil.txt</strong> (causando o conflito proposital):</p><ul><li>Cria uma branch (partindo da develop):</li></ul><pre>git checkout -b feature/configuracao</pre><ul><li>Cria um arquivo chamado <em>config.txt</em>.</li></ul><blockquote><strong>Atenção:</strong> <br>O DevOps A também cria um arquivo perfil.txt (mesmo nome que o B) e escreve o nome dele.</blockquote><ul><li>Faz o commit: git add . e git commit -m “feat: adiciona configuracoes de sistema”.</li><li>Envia para o GitHub: git push origin feature/configuracao.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cB-Q-4Vu1VtbAvmyVESyAw.png" /></figure><h3>Fase 3: Code Review e Merge</h3><ol><li>O <strong>DevOps B</strong> abre um Pull Request (PR) de feature/perfil-usuario para develop:</li></ol><ul><li><strong>Acesse o Repositório</strong>: <br>No navegador, abra a página principal do repositório lab-git-avancado.</li><li><strong>Identifique o Banner de Comparação</strong>: <br>Como você acabou de fazer o <em>push</em> da sua branch, o GitHub geralmente exibe um banner amarelo no topo da página com o texto: <em>“feature/perfil-usuario had recent pushes less than a minute ago”</em>.<br>Clique no botão verde <strong>“Compare &amp; pull request”</strong>.</li><li><strong>Configure as Branches (Origem e Destino)</strong>:<br>No topo da página de criação do PR, você verá dois seletores:<br>- <strong>base:</strong> mude para develop (é para onde o código vai).<br>- <strong>compare:</strong> certifique-se de que está em feature/perfil-usuario <br>(é de onde o código vem).</li><li><strong>Título e Descrição</strong>:<br>- No título, utilize o padrão de <em>Conventional Commits</em>, por exemplo: feat: <br>adiciona perfil do DevOps B.<br>- Na descrição, escreva brevemente o que foi feito <br>(ex: “Criação do arquivo perfil.txt para o lab de Git avançado”).</li><li><strong>Solicite a Revisão</strong>: <br>No lado direito da tela, em <strong>Reviewers</strong>, clique na engrenagem e selecione o <strong>DevOps A</strong>.</li><li><strong>Criar o PR</strong>: <br>Clique no botão verde <strong>“Create pull request”</strong>.</li></ul><p>2. Para que o <strong>DevOps A</strong> realize a revisão de código (Code Review) de forma profissional no GitHub, seguindo as boas práticas de engenharia, ele deve seguir este passo a passo:</p><ul><li><strong>Localizar o Pull Request (PR)<br>- </strong>No repositório lab-git-avancado, clique na aba <strong>“Pull requests”</strong> no menu superior.<br>- Clique no PR que foi aberto pelo <strong>DevOps B</strong> <br>(ex: <em>feat: adiciona perfil do DevOps B</em>).</li><li><strong>Revisar as Alterações (Files Changed)<br>- </strong>Dentro do PR, clique na aba <strong>“Files changed”</strong> (fica logo abaixo do título do PR).<br>- Aqui você verá o “diff”: O que foi removido (em vermelho) e o que foi adicionado (em verde).<br>- Analise se o código segue os padrões da equipe e se não há erros óbvios.</li><li><strong>Comentar Sugerindo Melhorias<br>- </strong>Passe o mouse sobre a linha de código onde deseja sugerir uma alteração.<br>- Clique no ícone de <strong>“+” (azul)</strong> que aparece ao lado do número da linha.<br>- Escreva seu comentário técnico (ex: <em>“Sugiro adicionar também seu e-mail ou cargo aqui para completar o perfil”</em>).<br>- Clique em <strong>“Start a review”</strong>. Isso agrupa seus comentários para que o DevOps B não receba uma notificação para cada frase digitada.</li><li><strong>Finalizar e Aprovar a Revisão<br>- </strong>Após fazer os comentários necessários, clique no botão verde <strong>“Finish your review”</strong> (no canto superior direito da lista de arquivos).<br>- Um campo de texto aparecerá para um feedback geral. Você tem três opções:<br><strong>Comment</strong>: Apenas envia os comentários sem aprovar nem reprovar.<br><strong>Approve</strong>: Confirma que o código está pronto para ser mesclado (merge).<br><strong>Request changes</strong>: Bloqueia o merge até que o DevOps B faça as correções sugeridas.<br>- Selecione <strong>“Approve”</strong>.<br>- Clique em <strong>“Submit review”</strong>.</li></ul><blockquote><strong>Status do PR</strong>: <br> O status do Pull Request mudará para “Approved” (ficará com um check verde).</blockquote><p>3. O PR foi aprovado, agora é preciso fazer o merge na develop:</p><ul><li><strong>Ação do DevOps B (ou A)</strong>: <br>Alguém precisa clicar no botão verde <strong>“Merge pull request”</strong>, que agora estará liberado (ou sem avisos de bloqueio).</li><li><strong>Confirmar Merge</strong>: <br>Após clicar em “Merge pull request”, aparecerá um botão escrito <strong>“Confirm merge”</strong>. Só após esse segundo clique é que o arquivo perfil.txt passará a existir oficialmente na branch develop.</li></ul><blockquote>Ao finalizar, verifique o gráfico em <strong>Insights &gt; Network</strong> no GitHub. A linha de história não deve estar linear e organizada.</blockquote><h3>Fase 4: O Desafio do Rebase (Resolvendo o Conflito)</h3><p>Agora o <strong>DevOps A</strong> tenta subir sua feature, mas a develop no servidor já mudou. Ele precisa sincronizar:</p><ol><li>Atualize sua base local:</li></ol><pre>git fetch origin<br>git rebase origin/develop</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/941/1*i2bQnBAJGArHqgTmmgGKOg.png" /></figure><p>2. O Git avisará sobre o conflito no perfil.txt, mas ele não escolhe sozinho; ele marca o arquivo e espera você limpar a “sujeira” das marcações:</p><ul><li><strong>Abra o arquivo no Bloco de Notas</strong></li><li><strong>Identifique as seções:<br>- </strong>Tudo entre &lt;&lt;&lt;&lt;&lt;&lt;&lt; HEAD e ======= é a <strong>sua versão</strong> (DevOps A).<br>- Tudo entre ======= e &gt;&gt;&gt;&gt;&gt;&gt;&gt; origin/develop é a <strong>versão que já estava no servidor</strong> (DevOps B).</li><li><strong>Faça a escolha:<br>- Quer manter a sua?</strong> Apague as linhas do DevOps B e os marcadores.<br>- <strong>Quer manter a dele?</strong> Apague as suas linhas e os marcadores.<br>- <strong>Quer as duas?</strong> <br> Apenas apague os marcadores (&lt;&lt;&lt;&lt;&lt;&lt;&lt;, =======, &gt;&gt;&gt;&gt;&gt;&gt;&gt;) e organize o texto.</li><li><strong>Salve (Ctrl + S) e feche o Bloco de Notas.</strong></li></ul><p>3. Depois finalize:</p><pre>git add perfil.txt<br>git rebase --continue</pre><blockquote><strong>Atenção:</strong> <br>Como o rebase reescreveu o histórico, você precisará forçar o push na sua branch de feature:</blockquote><pre>git push origin feature/configuracao - force</pre><h3>4. Explicações Didáticas</h3><ul><li><strong>Por que o Rebase?</strong> <br>Diferente do merge, o rebase coloca seus commits no topo da história atualizada, mantendo uma linha reta e limpa no gráfico do Git.</li><li><strong>O Perigo do Force Push:</strong> <br>Jamais use — force na main. <br>Ele é aceitável apenas em branches de feature que só você está usando, para alinhar o servidor após um rebase.</li><li><strong>Conventional Commits:</strong> <br>Usar prefixos como feat: ou fix: ajuda a automatizar changelogs e facilita a leitura da equipe.</li></ul><h3>5. Conclusão</h3><p>Ao finalizar, verifique o gráfico em <strong>Insights &gt; Network</strong> no GitHub. Se o Rebase foi bem feito, você verá uma linha de história linear e organizada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*-lLUpi4rklyjJ7AmoxM4Yw.png" /></figure><p>Chegar ao fim deste laboratório significa que você não apenas “mexeu no Git”, mas simulou o ciclo de vida real de uma alteração de infraestrutura ou código em uma equipe de alta performance.</p><h3>Principais aprendizados:</h3><ul><li><strong>A cultura de Code Review</strong>: <br>Você entendeu que o Pull Request não é uma burocracia, mas um ponto de controle de qualidade que evita que falhas de configuração cheguem ao ambiente de produção.</li><li><strong>Histórico Limpo com Rebase</strong>: <br>Aprender a usar o rebase em vez do merge para resolver conflitos localmente garante que o log do projeto seja linear e fácil de rastrear — algo vital quando precisamos fazer um <em>troubleshooting</em> rápido em Cloud.</li><li><strong>Segurança com Branch Protection</strong>: <br>Vimos que proteger a branch main impede que erros humanos (como um push — force acidental) destruam o trabalho da equipe.</li><li><strong>Resolução Ética de Conflitos</strong>: <br>Você aprendeu que conflitos são normais em ambientes colaborativos e que o desenvolvedor tem a responsabilidade de resolvê-los antes de entregar o código para revisão.</li></ul><h3>Próximos passos para sua carreira:</h3><p>Agora que você domina o fluxo de trabalho, o próximo nível é automatizar o que fizemos manualmente:</p><ul><li><strong>GitHub Actions</strong>: <br>Que tal criar um pipeline que testa se o seu código está correto assim que você abre o Pull Request?</li><li><strong>Git Hooks</strong>: <br>Configure scripts locais que impedem commits que não seguem o padrão <em>Conventional Commits</em>.</li><li><strong>Infrastructure as Code (IaC)</strong>: <br>Aplique este exato fluxo de Gitflow para gerenciar arquivos do <strong>Terraform</strong> ou manifestoss de <strong>Kubernetes</strong>.</li></ul><p><strong>Gostou desse hands-on?</strong> <br>Se tiver dúvidas no momento do rebase — continue, deixe um comentário abaixo!</p><p><strong>#DevOps #Git #CloudComputing #SoftwareEngineering #CarreiraTech</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=578c7d401fef" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>