Aprenda a amar as operações do segundo dia com gerenciamento de API baseado em GitOps

Vamos ser sinceros: pode ser difícil amar o Dia 2 — tudo o que acontece depois que um aplicativo é implantado em produção. Para muitos engenheiros que dão suporte a aplicativos modernos nativos da nuvem, o Dia 2 tem sido um período de monitoramento manual e processos de gerenciamento, operações isoladas e estresse por quebrar alguma coisa.

Uma parte essencial do motivo pelo qual o Dia 2 costuma ser tão desafiador em ambientes modernos é que eles envolvem toneladas de sistemas conectados, e gerenciar todos esses sistemas — e as APIs que os conectam — pode ser muito difícil. APIs são a cola que mantém unidos os aplicativos modernos e distribuídos; ainda assim, desenvolver, monitorar e atualizar APIs pode ser extremamente demorado e tedioso se você fizer isso de maneira imperativa e manual.

Esta é a situação das abordagens tradicionais de gerenciamento de APIs para aplicativos de microsserviços. Mas não precisa ser assim. Com uma estratégia mais moderna — baseada em Git e outras ferramentas centrais para operações modernas — você pode simplificar e agilizar as operações do Dia 2, mesmo com os aplicativos nativos da nuvem mais complexos.

Dia 2 e gerenciamento de API

As operações do dia 2 abrangem todas as tarefas – incluindo implantação de API, controle de versão, monitoramento, solução de problemas, mitigação de incidentes e atualizações – que as equipes devem realizar para manter os aplicativos em funcionamento continuamente.

Dado que um único aplicativo hoje depende de uma média de 26 e 50 APIs, de acordo com a Palo Alto Networks, há muitos motivos pelos quais o gerenciamento das operações do Dia 2 pode ser um desafio:

• Gerenciamento de mudanças lentas: Os desenvolvedores costumam fazer alterações em aplicativos modernos continuamente, mas implementar essas alterações pode ser um processo lento e tedioso. Isso é especialmente verdadeiro se as equipes precisarem testar e implantar cada nova versão manualmente ou se os processos de lançamento não forem totalmente automatizados.
• Análise de causa raiz: A natureza complexa dos aplicativos modernos, combinada com o grande número de APIs das quais eles dependem, significa que identificar a origem de uma falha não é uma tarefa simples. Por exemplo, se uma API envia uma solicitação malformada, como saber se o problema se deve a um problema de configuração da API, a uma falha no processamento do aplicativo, a uma falha na rede ou a algo mais? A resposta raramente é óbvia.
• Mitigação lenta de incidentes: A melhoria contínua, a ideia de que as equipes devem estar sempre em busca de oportunidades para melhorar aplicativos e APIs, anda de mãos dadas com ambientes modernos. Mas para colocar a melhoria contínua em prática, você deve ser capaz de documentar as mudanças tão rapidamente quanto as faz. Isso permite que sua equipe solucione com mais facilidade problemas ou incidentes que surgem após uma mudança.
• Colaboração: O monitoramento e o gerenciamento de aplicativos exigem colaboração entre diferentes partes interessadas, como engenheiros de TI (que normalmente detectam problemas de estabilidade ou desempenho), analistas de segurança (que identificam problemas de segurança) e desenvolvedores (que escrevem e atualizam códigos para corrigir problemas). A menos que cada grupo tenha acesso aos mesmos insights, será difícil para eles trabalharem juntos de forma eficiente.

Estes desafios distintos estão enraizados na mesma causa subjacente: a complexidade. Quando você tem arquiteturas de aplicativos e APIs complexas, inovar rapidamente e ao mesmo tempo mitigar riscos é muito mais difícil do que seria em ambientes mais simples. Um aplicativo monolítico baseado em máquina virtual que depende de poucas APIs, se houver, pode ser monitorado e atualizado com mais rapidez e menos complicações porque inclui menos peças móveis e menos pontos potenciais de falha. O mesmo não acontece com aplicativos nativos da nuvem.

Resolvendo problemas de gerenciamento de API no segundo dia com operações modernas

Diante dos desafios das operações do segundo dia para aplicativos modernos, o que uma equipe deve fazer?

A resposta errada é evitar arquiteturas complexas. Os aplicativos nativos da nuvem e as APIs que os alimentam são mais difíceis de gerenciar, mas evitá-los significa perder maior escalabilidade, confiabilidade, economia e outros benefícios importantes que os aplicativos modernos oferecem.

Uma estratégia mais saudável é desenvolver aplicativos nativos da nuvem (ou refatorar monólitos em uma arquitetura nativa da nuvem) sempre que fizer sentido e, ao mesmo tempo, aproveitar operações modernas para simplificar as operações do segundo dia.

Por exemplo, operações modernas significam usar Git para gerenciar e automatizar configurações de ambiente. Isso habilita o GitOps, que envolve a gravação de arquivos de configuração declarativos para recursos, o armazenamento e o controle de versão deles no Git e o envio automático de atualizações para ambientes de produção.

A abordagem GitOps simplifica alguns dos desafios mais profundos que cercam as operações do Dia 2, especialmente aqueles que envolvem APIs:

• Gerenciamento de mudanças simplificado: Quando você gerencia todas as suas configurações de API no Git, qualquer parte interessada que queira fazer uma alteração poderá fazê-lo por meio do repositório Git apropriado. Isso leva a uma resolução mais rápida de incidentes e a uma colaboração mais fácil entre as equipes.
• Fonte central da verdade: O Git se torna uma fonte central de verdade que qualquer pessoa da sua equipe pode usar para rastrear o status das configurações e implantações da API, junto com o restante da sua infraestrutura e aplicativos (já que suas configurações também são gerenciadas pelo Git). Isso também simplifica a colaboração entre equipes.
• Reversões instantâneas: Como as configurações armazenadas no Git são automaticamente controladas por versão, é fácil reverter uma alteração que causa um problema. Você pode reverter rapidamente para uma versão anterior do seu arquivo de configuração e restaurá-lo para um estado de funcionamento, ganhando tempo para resolver o problema que desencadeou a falha.
• Inovação mais rápida: O gerenciamento automatizado de configurações de API significa que você pode fazer alterações de forma rápida e eficiente, levando a inovações mais rápidas e engenheiros mais felizes, já que sua equipe não terá que dedicar tanto tempo e tédio para fazer melhorias.
• Capacidade de “falhar rápido”: A realização de verificações automatizadas de configuração por meio de linting e aproveitamento de implantações repetíveis ajuda as equipes a falharem rapidamente à medida que inovam, ao mesmo tempo que mantêm os riscos sob controle.

Resumindo, as operações modernas oferecem o melhor dos dois mundos no segundo dia: risco reduzido e inovação rápida e colaborativa. E como as operações modernas são automatizadas e repetíveis, você pode usá-lo para gerenciar 1.000 APIs com a mesma facilidade com que gerencia uma só. Sua capacidade de escalar é virtualmente ilimitada.

Aprendendo a amar, dia 2 novamente

As abordagens tradicionais de gerenciamento de API datam de antes da revolução nativa da nuvem, que tornou os ambientes distribuídos e altamente escaláveis ​​a norma. Hoje, as operações do Dia 2 exigem automação. Na verdade, a automação é a única maneira de colher os benefícios das estratégias nativas da nuvem.

Do ponto de vista do gerenciamento de APIs, a automação significa ir além do gerenciamento lento de mudanças, dos longos processos de recuperação e do controle deficiente sobre as APIs. Isso envolve a adoção de uma abordagem moderna, leve, modular, nativa do Kubernetes e baseada em GitOps para gerenciar APIs, que é o que você deve esperar de uma solução moderna de gerenciamento de API.

Para saber mais sobre o Kubernetes e o ecossistema nativo da nuvem, junte-se a nós na KubeCon + CloudNativeCon Europe em Paris, de 19 a 22 de março.

A postagem Aprenda a amar as operações do dia 2 com gerenciamento de API baseado em GitOps apareceu pela primeira vez em The New Stack.