Como Virar DevOps Engineer 2026: Roadmap

Você quer virar DevOps Engineer em 2026, mas olha as vagas no LinkedIn e parece que todo mundo pede Kubernetes, AWS, Terraform, CI/CD, observabilidade, segurança, Linux, Python, redes e ainda “boa comunicação”. Dá aquela sensação de que você precisa aprender 10 profissões antes de se candidatar.

A boa notícia: você não precisa saber tudo para começar. Mas precisa seguir uma ordem inteligente, montar projetos que provem sua capacidade e evitar perder meses em ferramentas soltas que não conversam entre si.

Como Virar DevOps Engineer 2026: Roadmap#

DevOps continua sendo uma das áreas mais fortes para quem quer crescer em tecnologia, principalmente porque empresas como Itaú, Nubank, Stone, iFood, Magalu e Globo precisam entregar software com segurança, velocidade e estabilidade.

Em 2026, a diferença entre um candidato júnior promissor e um candidato perdido não vai ser “saber o nome de 40 ferramentas”. Vai ser entender o fluxo inteiro:

1. Código sai do repositório.
2. Passa por testes.
3. Vira imagem ou pacote.
4. É implantado em um ambiente.
5. É monitorado.
6. Quando quebra, alguém consegue investigar rápido.
7. Quando cresce, a infraestrutura acompanha.

Esse é o coração de DevOps.

O que faz um DevOps Engineer na prática?#

Antes de estudar, você precisa saber qual problema essa pessoa resolve.

Um DevOps Engineer trabalha para reduzir o atrito entre desenvolvimento, infraestrutura, segurança e operação. Em empresas maiores, a pessoa pode atuar como Platform Engineer, SRE, Cloud Engineer ou Infrastructure Engineer, mas muita coisa se cruza.

Na prática, você pode trabalhar com:

• Automatização de deploys.
• Criação de pipelines CI/CD.
• Configuração de ambientes em AWS, Azure ou GCP.
• Infraestrutura como código com Terraform.
• Containers com Docker.
• Orquestração com Kubernetes.
• Monitoramento com Prometheus, Grafana, Datadog ou New Relic.
• Logs com ELK, Loki ou CloudWatch.
• Segurança em pipelines e ambientes.
• Melhorias de performance e disponibilidade.

Parece bastante, sim. Mas pense em camadas. Você não aprende tudo de uma vez, você constrói uma base e vai subindo.

Quanto ganha um DevOps Engineer em 2026?#

Os salários variam bastante por região, nível e empresa, mas DevOps segue muito competitivo.

No Brasil, uma faixa realista em 2026 pode ser:

• DevOps Júnior: R$ 5k a R$ 9k por mês.
• DevOps Pleno: R$ 10k a R$ 16k por mês.
• DevOps Sênior: R$ 17k a R$ 28k por mês.
• Especialista, Staff ou Platform Engineer: R$ 25k a R$ 40k por mês, especialmente em fintechs e empresas grandes.

Em empresas como Nubank, Itaú, Stone, iFood, Magalu e Globo, posições mais avançadas podem pagar muito bem, principalmente quando combinam cloud, Kubernetes, segurança e experiência em produção.

Para vagas remotas internacionais, a conversa muda. É comum ver posições entre $70k e $140k por ano para profissionais com bom inglês e experiência real. Algumas vagas passam disso, mas normalmente exigem histórico forte em ambientes críticos.

Agora, se você está começando, foque menos no salário da vaga sênior e mais no caminho até a primeira oportunidade. Ela é o ponto que muda o jogo.

Roadmap DevOps 2026: visão geral#

Aqui está a ordem que eu recomendaria para você estudar, principalmente se quer sair do zero ou migrar de suporte, QA, desenvolvimento ou infraestrutura tradicional:

1. Linux e terminal.
2. Redes e fundamentos de internet.
3. Git e GitHub.
4. Uma linguagem de script, como Python ou Bash.
5. Docker e containers.
6. CI/CD com GitHub Actions, GitLab CI ou Jenkins.
7. Cloud, começando por AWS.
8. Terraform.
9. Kubernetes.
10. Observabilidade.
11. Segurança DevSecOps.
12. Projetos de portfólio.
13. Currículo, LinkedIn e entrevistas.

A ordem importa porque cada etapa prepara a próxima. Se você tenta aprender Kubernetes sem Docker, sofre. Se tenta cloud sem redes, decora botão de console e não entende o que está fazendo.

Etapa 1: Linux e terminal#

DevOps sem Linux é como motorista sem noção de trânsito. Você até pode apertar botões em ferramentas, mas vai travar quando precisar investigar logs, permissões, processos e rede.

Você não precisa ser um administrador Linux clássico no começo, mas precisa estar confortável no terminal.

O que aprender em Linux

Comece por:

• Navegação: cd, ls, pwd.
• Arquivos: cat, less, head, tail, cp, mv, rm.
• Permissões: chmod, chown, usuários e grupos.
• Processos: ps, top, htop, kill.
• Serviços: systemctl, journalctl.
• Logs em /var/log.
• Rede: curl, ping, netstat, ss, dig, nslookup.
• Shell scripting básico.

Um exercício bom: suba uma máquina Ubuntu no seu computador, em uma VM, ou use uma instância pequena na AWS. Instale Nginx, sirva uma página HTML, veja logs, pare e reinicie o serviço.

Parece simples, mas isso já te coloca acima de muita gente que só assistiu curso e nunca quebrou nada.

Etapa 2: Redes para DevOps#

Você não precisa virar engenheiro de redes, mas precisa entender como aplicações conversam.

Se uma API não responde em produção, você precisa conseguir raciocinar:

• O DNS resolveu?
• A porta está aberta?
• O firewall permite?
• O load balancer está saudável?
• O certificado TLS está válido?
• O container está escutando na porta certa?
• O serviço interno está apontando para o destino certo?

Conceitos essenciais

Estude:

1. IP, portas e protocolos.
2. TCP e UDP.
3. HTTP e HTTPS.
4. DNS.
5. TLS/SSL.
6. Load balancer.
7. Proxy e reverse proxy.
8. NAT e firewall.
9. CIDR e subnets.
10. Latência, timeout e retry.

Um projeto simples: crie duas aplicações Docker, uma API e um banco PostgreSQL, e faça uma conversar com a outra em uma rede Docker. Depois coloque Nginx como reverse proxy na frente.

Esse projeto pequeno ensina mais do que muita teoria solta.

Etapa 3: Git e GitHub de verdade#

Quase toda automação DevOps começa quando alguém faz push em um repositório.

Você precisa saber Git bem o suficiente para trabalhar sem medo, entender branches e revisar pipelines que rodam a partir de pull requests.

O que dominar

Aprenda:

• git clone, status, add, commit, push, pull.
• Branches e merges.
• Pull requests.
• Tags e releases.
• .gitignore.
• Resolução básica de conflitos.
• GitHub Actions ou GitLab CI disparando por evento.

Para treinar, crie um repositório público com uma aplicação simples. Pode ser Node.js, Python Flask, Go ou Java Spring Boot. O importante é ter algo versionado, com README claro e histórico de commits.

Se você quer ser levado a sério em uma vaga DevOps júnior, seu GitHub precisa mostrar que você sabe organizar trabalho técnico.

Etapa 4: Bash e Python#

DevOps vive de automação. Você não precisa ser dev backend sênior, mas precisa escrever scripts úteis.

Bash ajuda muito no dia a dia do Linux. Python ajuda quando a automação começa a ficar maior, com APIs, arquivos JSON, integrações e relatórios.

O que fazer com Bash

Treine scripts para:

• Fazer backup de arquivos.
• Ler variáveis de ambiente.
• Validar se um serviço está rodando.
• Fazer chamadas com curl.
• Processar logs simples.
• Automatizar comandos repetitivos.

O que fazer com Python

Treine scripts para:

• Consumir uma API.
• Ler e escrever JSON.
• Fazer upload de arquivo.
• Verificar status de endpoints.
• Gerar relatório simples.
• Automatizar tarefas em cloud usando SDK.

Um exemplo de projeto legal: crie um script Python que verifica a saúde de 5 endpoints, mede tempo de resposta e salva um relatório em JSON. Depois coloque esse script rodando em um pipeline.

Pronto, você já está juntando programação, automação e CI/CD.

Etapa 5: Docker e containers#

Docker é obrigatório para DevOps moderno. Antes de Kubernetes, antes de cloud avançada, antes de pipeline bonito, você precisa entender container.

Container resolve um problema clássico: “na minha máquina funciona”. Ele empacota aplicação e dependências em uma imagem que pode rodar em vários ambientes.

O que aprender em Docker

Foque em:

• Imagens e containers.
• Dockerfile.
• docker build.
• docker run.
• Portas e volumes.
• Variáveis de ambiente.
• Redes Docker.
• Docker Compose.
• Registry, como Docker Hub ou GitHub Container Registry.

Projeto recomendado

Pegue uma aplicação simples e faça:

1. Criar um Dockerfile.
2. Rodar localmente com docker run.
3. Criar um docker-compose.yml com app e banco.
4. Configurar variáveis de ambiente.
5. Publicar a imagem em um registry.
6. Documentar tudo no README.

Esse projeto é perfeito para portfólio. Se você conseguir explicar por que separou app e banco, como as variáveis funcionam e como os containers conversam, já tem conversa boa para entrevista.

Etapa 6: CI/CD sem mistério#

CI/CD é onde muita gente começa a parecer DevOps de verdade.

CI significa integração contínua. Na prática, quando você faz push ou abre pull request, uma automação roda testes, validações e build.

CD pode significar entrega contínua ou deploy contínuo. Na prática, depois de passar pelas etapas, o código pode ser entregue em um ambiente.

Ferramentas para escolher

Em 2026, eu começaria com GitHub Actions, porque é fácil, popular e bom para portfólio.

Depois você pode estudar:

• GitLab CI.
• Jenkins.
• Azure DevOps.
• CircleCI.
• Argo CD, para GitOps em Kubernetes.

Pipeline inicial para seu portfólio

Monte um pipeline que faça:

1. Checkout do código.
2. Instalação de dependências.
3. Execução de testes.
4. Build da imagem Docker.
5. Scan básico de segurança.
6. Push da imagem para registry.
7. Deploy em um ambiente simples.

Pode ser deploy em uma VPS, em uma instância EC2, em um serviço gerenciado ou até em um cluster local para começar.

O ponto é mostrar fluxo. Recrutadores técnicos querem ver que você entende a sequência.

Etapa 7: Cloud, comece por AWS#

Cloud é uma das partes que mais pesa em vagas DevOps. A AWS aparece muito em empresas brasileiras e internacionais, então é uma boa primeira escolha.

Isso não quer dizer que Azure ou GCP sejam ruins. Itaú e empresas grandes podem usar múltiplas clouds. Mas para roadmap, escolha uma e vá fundo o suficiente.

O que estudar na AWS

Comece por:

• IAM, usuários, roles e políticas.
• VPC, subnets, route tables e security groups.
• EC2.
• S3.
• RDS.
• Load Balancer.
• CloudWatch.
• ECR.
• ECS ou EKS.
• Lambda, pelo menos no básico.

Não tente clicar em tudo no console sem entender custo. AWS cobra em dólar, então coloque alerta de orçamento desde o primeiro dia.

Projeto AWS para DevOps júnior

Um projeto forte:

1. Criar uma VPC simples.
2. Subir uma EC2 com Docker.
3. Fazer deploy de uma aplicação containerizada.
4. Usar RDS como banco.
5. Colocar um Load Balancer na frente.
6. Enviar logs para CloudWatch.
7. Documentar arquitetura com diagrama.

Isso já parece muito com trabalho real.

Etapa 8: Terraform e infraestrutura como código#

Terraform é uma habilidade que separa quem “clica no console” de quem cria infraestrutura repetível.

Infraestrutura como código significa declarar recursos em arquivos. Assim, você consegue revisar, versionar, aplicar e destruir ambientes de forma controlada.

O que aprender em Terraform

Foque em:

• Providers.
• Resources.
• Variables.
• Outputs.
• State.
• Remote state.
• Modules.
• Workspaces, com cuidado.
• terraform plan e terraform apply.

No começo, evite módulos muito complexos. Escreva recursos simples para entender o que está acontecendo.

Projeto bom de Terraform

Crie com Terraform:

• Uma VPC.
• Subnets públicas e privadas.
• Security groups.
• Uma EC2.
• Um bucket S3.
• Um banco RDS pequeno, se couber no orçamento.

Depois destrua tudo com terraform destroy.

Esse tipo de projeto mostra maturidade porque você não só sobe recurso, você controla ciclo de vida.

Etapa 9: Kubernetes sem pânico#

Kubernetes assusta porque tem muitos conceitos. Mas você não precisa decorar tudo de uma vez.

Kubernetes é uma plataforma para rodar containers em escala. Ele ajuda com deploy, auto recuperação, balanceamento, configuração, secrets e organização de serviços.

Conceitos essenciais

Aprenda:

• Pod.
• Deployment.
• Service.
• ConfigMap.
• Secret.
• Namespace.
• Ingress.
• Volume.
• Helm.
• Requests e limits.
• Liveness e readiness probes.

Comece local com Kind ou Minikube. Depois vá para EKS, GKE ou AKS.

Projeto Kubernetes para portfólio

Faça:

1. Criar cluster local com Kind.
2. Fazer deploy da aplicação.
3. Criar Service.
4. Criar Ingress.
5. Configurar ConfigMap e Secret.
6. Adicionar probes.
7. Criar chart Helm simples.
8. Documentar comandos.

Se quiser subir o nível, use Argo CD para GitOps. Aí você mostra que entende deploy controlado a partir do Git.

Etapa 10: Observabilidade#

Produção não é só fazer deploy. Produção é saber o que está acontecendo quando o usuário reclama.

Observabilidade junta métricas, logs e traces para entender comportamento de sistemas.

O que estudar

Comece com:

• Métricas.
• Logs.
• Traces.
• Alertas.
• SLO, SLA e SLIs.
• Dashboards.
• Latência.
• Taxa de erro.
• Saturação.
• Disponibilidade.

Ferramentas comuns:

• Prometheus.
• Grafana.
• Loki.
• ELK.
• Datadog.
• New Relic.
• CloudWatch.

Projeto prático

Adicione Prometheus e Grafana ao seu projeto Kubernetes. Crie um dashboard com:

• Uso de CPU.
• Uso de memória.
• Número de requests.
• Taxa de erro.
• Latência média.

Depois configure um alerta simples. Por exemplo: se a API retornar erro 500 em excesso, gerar alerta.

Isso mostra que você pensa além do deploy. E empresas gostam muito disso.

Etapa 11: Segurança DevSecOps#

Em 2026, DevOps sem segurança fica fraco. As empresas querem velocidade, mas não querem vazar dado, expor segredo ou colocar imagem vulnerável em produção.

Você não precisa virar especialista em segurança no começo, mas precisa incorporar práticas básicas.

O que aprender

Estude:

• Gestão de secrets.
• Princípio do menor privilégio em IAM.
• Scan de imagem Docker.
• Scan de dependências.
• Scan de IaC.
• Assinatura e verificação de artefatos, no básico.
• TLS.
• Políticas de rede.
• Auditoria e logs.
• Rotação de credenciais.

Ferramentas úteis:

• Trivy.
• Snyk.
• Dependabot.
• Checkov.
• Gitleaks.
• AWS Secrets Manager.
• HashiCorp Vault.

Um pipeline com Trivy e Gitleaks já passa uma ótima impressão em vaga júnior ou pleno inicial.

Certificações ajudam?#

Ajudam, mas não substituem projeto.

Se você está começando, boas certificações são:

1. AWS Cloud Practitioner, para base.
2. AWS Solutions Architect Associate.
3. HashiCorp Terraform Associate.
4. Certified Kubernetes Administrator, quando já tiver prática.
5. Certified Kubernetes Application Developer, se você vem de desenvolvimento.

Para uma primeira vaga DevOps, eu prefiro ver 3 projetos bem feitos no GitHub do que 5 certificações sem prática.

Mas certificação pode ajudar seu currículo a passar em filtros de RH, principalmente quando a vaga pede AWS, Kubernetes ou Terraform.

Roadmap de 6 meses para virar DevOps#

Se você tem 10 a 15 horas por semana, este plano é realista.

Mês 1: Linux, Git e redes

Objetivo: ficar confortável no terminal e entender como sistemas conversam.

Faça:

• Instale Linux ou use WSL.
• Estude comandos básicos.
• Suba Nginx.
• Aprenda Git e GitHub.
• Estude HTTP, DNS, portas e TLS.
• Crie um README bem escrito.

Entrega do mês: servidor Nginx documentado, com comandos e explicação.

Mês 2: Docker e automação

Objetivo: empacotar aplicação e automatizar tarefas.

Faça:

• Estude Dockerfile.
• Use Docker Compose.
• Escreva scripts Bash.
• Escreva scripts Python simples.
• Publique imagem no Docker Hub.

Entrega do mês: app com Docker Compose, banco e documentação.

Mês 3: CI/CD

Objetivo: criar pipeline de ponta a ponta.

Faça:

• Aprenda GitHub Actions.
• Rode testes no pipeline.
• Faça build de imagem.
• Faça push para registry.
• Adicione scan com Trivy.

Entrega do mês: pipeline funcionando a cada push.

Mês 4: AWS

Objetivo: colocar aplicação em cloud.

Faça:

• Estude IAM, EC2, S3, VPC e RDS.
• Crie alerta de custo.
• Suba aplicação em EC2.
• Configure banco RDS.
• Use CloudWatch.

Entrega do mês: aplicação online em AWS com diagrama.

Mês 5: Terraform

Objetivo: criar infraestrutura como código.

Faça:

• Escreva Terraform para VPC e EC2.
• Versione no GitHub.
• Use variables e outputs.
• Teste plan, apply e destroy.

Entrega do mês: infraestrutura criada por código.

Mês 6: Kubernetes e observabilidade

Objetivo: entrar no mundo de orquestração e monitoramento.

Faça:

• Use Kind ou Minikube.
• Crie manifests.
• Use Helm básico.
• Instale Prometheus e Grafana.
• Crie dashboard.

Entrega do mês: app rodando em Kubernetes com métricas.

Projetos de portfólio que chamam atenção#

Seu portfólio precisa contar uma história. Não coloque 20 repositórios vazios. Coloque 3 projetos fortes e bem documentados.

Projeto 1: Pipeline CI/CD com Docker

Inclua:

• Aplicação simples.
• Testes automatizados.
• Dockerfile.
• GitHub Actions.
• Scan de segurança.
• Push para registry.

Projeto 2: Deploy em AWS com Terraform

Inclua:

• VPC.
• EC2 ou ECS.
• RDS ou S3.
• Security groups.
• CloudWatch.
• Diagrama da arquitetura.
• Instruções de deploy.

Projeto 3: Kubernetes com observabilidade

Inclua:

• Manifests ou Helm chart.
• Ingress.
• ConfigMap e Secret.
• Probes.
• Prometheus.
• Grafana.
• Alertas simples.

Para cada projeto, escreva no README:

1. Qual problema ele resolve.
2. Arquitetura.
3. Ferramentas usadas.
4. Como rodar localmente.
5. Como fazer deploy.
6. Prints ou GIFs.
7. O que você faria melhor em produção.

Esse último ponto é muito bom. Mostra maturidade e senso crítico.

Como montar seu currículo DevOps#

Seu currículo precisa bater com a vaga e com o ATS, aquele sistema que filtra currículos antes de chegar em uma pessoa.

Coloque palavras-chave reais, mas só se você souber defender em entrevista.

Palavras-chave úteis

Use termos como:

• Linux.
• Docker.
• Kubernetes.
• AWS.
• Terraform.
• GitHub Actions.
• CI/CD.
• Observability.
• Prometheus.
• Grafana.
• CloudWatch.
• Python.
• Bash.
• Infrastructure as Code.
• DevSecOps.
• IAM.
• VPC.

Exemplo de bullet bom

Em vez de escrever:

• “Estudei Docker e AWS.”

Escreva:

• “Criei pipeline CI/CD com GitHub Actions para build, teste, scan com Trivy e publicação de imagem Docker no GitHub Container Registry.”

Outro exemplo:

• “Provisionei infraestrutura AWS com Terraform, incluindo VPC, EC2, security groups e bucket S3, com documentação de execução e destruição do ambiente.”

Isso é mais concreto e passa mais confiança.

Como se preparar para entrevistas DevOps#

Entrevista DevOps costuma misturar teoria, prática e cenário.

Você pode receber perguntas como:

• O que acontece quando você acessa um site no navegador?
• Como investigar uma API lenta?
• Qual a diferença entre container e VM?
• Como funciona um pipeline CI/CD?
• Como você protegeria secrets?
• O que é um security group?
• Quando usar Kubernetes?
• Como lidar com rollback?
• Como investigar um pod em CrashLoopBackOff?
• Qual a diferença entre readiness e liveness probe?

Treine responder com exemplos dos seus projetos. Não tente parecer que sabe tudo. Uma resposta honesta e estruturada vale mais do que enrolar.

Use este formato:

1. “Eu começaria verificando…”
2. “Depois olharia…”
3. “Se isso estivesse ok, investigaria…”
4. “No meu projeto, fiz algo parecido quando…”

Isso passa raciocínio operacional.

Erros que atrasam sua transição#

Alguns erros custam meses.

Evite:

• Estudar Kubernetes antes de Docker.
• Pular redes.
• Só assistir curso e não criar projeto.
• Ter GitHub vazio.
• Não documentar nada.
• Usar AWS sem alerta de custo.
• Decorar comandos sem entender problema.
• Candidatar-se com currículo genérico.
• Ignorar inglês técnico.
• Fingir experiência em produção.

Você pode ser iniciante e ainda assim ser forte. Basta mostrar clareza, prática e evolução.

Inglês importa?#

Sim. Mesmo para vagas no Brasil.

Documentação, issues, tutoriais, logs, mensagens de erro e entrevistas melhores quase sempre envolvem inglês. Para vagas remotas internacionais pagando $80k, $100k ou mais por ano, o inglês vira requisito central.

Você não precisa falar como nativo. Precisa conseguir:

• Ler documentação.
• Explicar projetos.
• Participar de reuniões.
• Escrever mensagens técnicas.
• Entender perguntas em entrevista.

Uma dica simples: mude seus estudos para inglês aos poucos. Leia docs oficiais, escreva README bilingue e grave você explicando um projeto por 3 minutos.

Seu próximo passo#

Se eu fosse começar hoje, faria assim:

1. Escolheria uma aplicação simples.
2. Colocaria em Docker.
3. Criaria pipeline no GitHub Actions.
4. Faria deploy em AWS.
5. Recriaria infraestrutura com Terraform.
6. Depois levaria para Kubernetes.
7. Por fim, adicionaria observabilidade e segurança básica.

Esse caminho te dá uma narrativa clara: “eu peguei uma aplicação e construí um fluxo moderno de entrega”.

É isso que DevOps faz.

Você não precisa ser perfeito para se candidatar. Mas precisa provar que sabe aprender, automatizar, investigar e documentar.

Antes de enviar currículo para vagas DevOps em Itaú, Nubank, Stone, iFood, Magalu, Globo ou empresas remotas pagando em dólar, confira se seu currículo está passando pelos filtros certos. Use o verificador gratuito da JobRise e ajuste seu currículo antes de aplicar: teste seu currículo no ATS grátis.