Você deve usar o Kubernetes? A resposta, em resumo, depende. Mas deixe-me guiá-lo em minha jornada para entender o Kubernetes, e talvez isso possa ajudá-lo a encontrar sua própria resposta.
Escrevi um livro inteiro para ajudar a guiá-lo em seu caminho para o Kubernetes (obtenha o MEAP de lançamento antecipado da Manning aqui). Mas antes de falarmos sobre o livro, vamos falar um pouco sobre a implantação de software e minha jornada até lá.
Há quase duas décadas, embarquei em minha primeira tentativa de implantar software na Internet para publicar meu primeiro site. Naquela época, eu não tinha a menor ideia de por onde começar. Alguns amigos da família tiveram a gentileza de me dar alguns conselhos:
O empresário sugeriu:
"Pegue este livro sobre Dreamweaver e HTML e você não precisará gastar um centavo para desenvolver seu primeiro site."
O administrador do sistema e o desenvolvedor adotaram uma abordagem diferente:
"Aqui, deixe-me configurar um servidor FTP para você hospedar seu site; não recomendo aprender a gerenciar servidores."
Essas duas pessoas me ajudaram a chegar onde estou hoje, mas uma delas atrasou involuntariamente meu aprendizado por um longo tempo. Você consegue adivinhar quem foi?
Ao relembrar meus primeiros dias, fica claro como o conhecimento básico e o aprendizado por meio da experiência prática foram cruciais para moldar minha jornada. O conselho empresarial me levou a mergulhar de cabeça no desenvolvimento da Web, enquanto a orientação do administrador de sistemas me ensinou o valor das ferramentas que poderiam simplificar tarefas complexas.
No entanto, uma lição fundamental que surgiu com o passar do tempo foi a importância de compreender os princípios fundamentais, mesmo ao usar ferramentas de alto nível. Essa experiência de aprendizado inicial foi a gênese do meu interesse no Kubernetes, uma tecnologia que teria um impacto significativo na minha trajetória profissional. Para entender o Kubernetes, como qualquer outra ferramenta, é preciso ter uma compreensão firme da tecnologia subjacente.
O Kubernetes é complexo? Sim. Ele é perfeito? Não. É adequado para todas as situações? Não. Mas a questão de saber se você deve ou não usar o Kubernetes geralmente se resume à sua compreensão da tecnologia subjacente que torna o Kubernetes tão avançado e como você pode usá-lo para gerenciar e proteger seu software.
Para aqueles que estão se perguntando: "O que é Kubernetes?" ou talvez ainda não estejam familiarizados com o termo "Docker" (além do tipo de calça) e sua associação com contêineres, permita-me explicar.
Os aplicativos estão em constante evolução, com cada componente, do banco de dados à linguagem de programação, lançando novas versões com frequência. Manter o controle de várias versões de cada aplicativo e de inúmeras iterações de componentes de terceiros pode se tornar um problema de gerenciamento, especialmente quando se trata de versões mais antigas ou legadas sem suporte convencional. Mesmo as versões suportadas do software têm muitas dependências de instalação em nível de sistema e de terceiros que podem aumentar a complexidade da execução do software, sem falar na tentativa de usá-lo como um componente do seu aplicativo.
Com o tempo, todo software acaba se tornando obsoleto e é substituído por versões mais recentes. O desafio está em executar softwares mais antigos quando necessário. Mesmo mudanças aparentemente pequenas no software podem ter um impacto enorme nos aplicativos modernos. Por exemplo, o Python 2.7 (em comparação com o mais recente Python 3.11) costumava ser incorporado ao Mac OS X da Apple. O Python 2.7 tinha uma sintaxe estranha para a saída de texto para a linha de comando: `print "this thing" ` em vez da versão mais lógica de `print("this thing")` presente nas versões mais recentes do Python. Essa sintaxe pode quebrar um aplicativo Python legado inteiro devido à falta de parênteses.
Embora o uso de versões mais antigas de software possa ser impraticável, certamente há situações em que precisamos executar softwares mais antigos. Mas como?
Poderíamos gastar tempo para encontrar uma peça de hardware ou uma imagem de VM de um momento específico que nos permitisse executar um software antigo. Ou podemos recorrer aos contêineres, um conceito pioneiro do Docker. Os contêineres são aplicativos independentes, empacotados com suas dependências, que podem ser modificados conforme necessário. Seu ponto de venda exclusivo é a capacidade de fazer uma transição perfeita de um sistema para outro.
Aqui está um exemplo de Dockerfile que usa o Python 2.7 como bloco de construção de um contêiner:
```dockerfile
FROM python:2.7.7-slim
COPY ./src /app/
WORKDIR /app
RUN python -m pip install -r requirements.txt
CMD [“python”, “manage.py”, “runserver”]
``````dockerfile
FROM python:2.7.7-slim
COPY ./src /app/
WORKDIR /app
RUN python -m pip install -r requirements.txt
CMD [“python”, “manage.py”, “runserver”]
```Esse Dockerfile informa ao Docker o que é necessário para criar esse novo contêiner com o código que existe em nossa máquina local e no caminho local em `/src`. Os Dockerfiles podem se tornar muito mais complicados, mas este exemplo mostra como é fácil usar o Docker.
Para criar e executar esse aplicativo em contêiner, é tão simples quanto:
```bash
docker build -f Dockerfile -t hello-python:v1 .
docker run hello-python -p 8000:8000
```Sem a conteinerização, teríamos que instalar o Python 2.7 diretamente em um computador, o que quase nunca é simples. O Docker e outros contêineres podem tornar nossos aplicativos portáteis, e você pode substituir o Python 2.7 neste exemplo por praticamente qualquer linguagem ou ferramenta de código aberto.
No entanto, o problema surge quando queremos atualizar um aplicativo em contêiner, especialmente na produção. Localmente, atualizar um contêiner é simples. Você para de executar o contêiner, reconstrói-o e, em seguida, executa-o novamente. Na produção, no entanto, a atualização de um contêiner pode ser feita da mesma forma, mas corremos o risco de um grande tempo de inatividade se a compilação falhar.
É aí que entra o Kubernetes. O Kubernetes ajuda a gerenciar o roteamento de tráfego para contêineres específicos e supervisiona o número de contêineres em execução em um determinado momento. Se um contêiner estiver falhando, o Kubernetes facilita a reversão para versões anteriores com o mínimo ou nenhum tempo de inatividade.
A configuração para a implantação de um contêiner no Kubernetes é chamada de manifesto. Aqui está um exemplo de um manifesto relativamente simples:
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: hello-py-deploy
spec:
replicas: 3
selector:
matchLabels:
app: hello-py-deploy
template:
metadata:
labels:
app: hello-py-deploy
spec:
containers:
- name: hello-py-container
image: jmitchel3/hello-python:v1
ports:
- containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
name: hello-py-service
spec:
type: LoadBalancer
ports:
- name: http
port: 80
targetPort: 8080
protocol: TCP
selector:
app: hello-py-deploy
```No exemplo acima, o manifesto do Kubernetes formatado em yaml provisiona dois recursos: um serviço de balanceamento de carga e uma implantação. O balanceador de carga ajuda a rotear o tráfego para nossa implantação. Por meio de `replicas: 3`, do nosso contêiner declarado `hello-python:v1`, nossa implantação está executando 3 versões.
Agora, quando quisermos atualizar a versão implantada, podemos simplesmente alterar `hello-python:v1` para `hello-python:v2` e o Kubernetes atualizará nosso aplicativo de forma adequada. E se algo der errado, ele reverterá para `hello-py-deploy:v1`. O Kubernetes torna esse processo indolor e fácil de gerenciar. Os manifestos podem ser facilmente controlados por versão com o git, de modo que podemos ser muito granulares com nossos recursos de reversão. O Kubernetes é essencial para a implantação porque fornece uma estrutura para automatizar, dimensionar e gerenciar aplicativos em contêineres, garantindo a resiliência e a eficiência do sistema em nossos cenários de software cada vez mais complexos.
Gostaria de abordar apenas alguns dos métodos que me levaram a descobrir como o Kubernetes poderia simplificar minhas implementações de aplicativos. Obter o máximo do Kubernetes exigiu várias etapas para mim, mas foi uma jornada que valeu a pena. Em Road to Kubernetes, faremos uma jornada para implantar aplicativos usando várias tecnologias que são importantes para entender antes de entrar no Kubernetes e em outras práticas de implantação modernas.
Em Road to Kubernetes, veremos como fazer isso:
- Gerenciar repositórios git em plataformas auto-hospedadas ou em nuvem
- Implante aplicativos Python e Node.js por meio de VMs baseadas na nuvem com o git
- Automatize a configuração e a implementação de VMs com Ansible
- Containerize e implemente aplicativos com o Docker e o Docker Compose
- Execute contêineres diretamente em VMs sem orquestração
- Envie e hospede contêineres com o registro do DockerHub
- Implante aplicativos em contêineres no Kubernetes
- Implementar aplicativos públicos e privados no Kubernetes
- Configurar balanceadores de carga para tráfego HTTP e HTTPs
- Use técnicas de CI/CD com o Github Actions e o ato alternativo de código aberto da Nectos
- e muito mais!
A implantação é o teste definitivo de seu software. Road to Kubernetes condensa quinze anos de aprendizados sobre implantação em um guia acessível e prático. Ele leva você da implantação de software do zero até a implementação do poder do Kubernetes. Você aprenderá práticas de implantação sustentáveis que podem ser usadas com qualquer linguagem e qualquer tipo de aplicativo da Web, como criar aplicativos portáteis que podem ser movidos entre opções de implantação e provedores de nuvem, e verá como é possível utilizar o Kubernetes em projetos de qualquer tamanho.
Para começar a entender o Kubernetes, obtenha o MEAP de lançamento antecipado da Manning aqui.
Comentários