Deve utilizar o Kubernetes? A resposta, em suma, depende. Mas deixe-me guiá-lo através da 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 no 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 na minha primeira tentativa de implementar software na Internet para publicar o meu primeiro sítio Web. Na altura, não fazia a mínima ideia por onde começar. Alguns amigos da família tiveram a amabilidade de me dar alguns conselhos:
sugeriu o empresário:
"Pegue neste livro sobre Dreamweaver e HTML e não precisará de gastar um cêntimo para desenvolver o seu primeiro site."
O administrador do sistema e o programador adoptaram uma abordagem diferente:
"Aqui, deixe-me configurar um servidor FTP para alojar o seu sítio Web; não recomendo que aprenda a gerir servidores."
Ambas as pessoas me ajudaram a chegar onde estou hoje, mas uma delas atrasou involuntariamente a minha aprendizagem durante muito tempo. Consegues adivinhar quem foi?
Olhando para trás, para os meus primeiros dias, torna-se claro como o conhecimento fundamental e a aprendizagem através da experiência prática foram cruciais para moldar o meu percurso. Os conselhos empresariais levaram-me a mergulhar no desenvolvimento Web, enquanto a orientação do administrador de sistemas me ensinou o valor das ferramentas que podiam simplificar tarefas complexas.
No entanto, uma lição fundamental que surgiu com o tempo foi a importância de entender os princípios fundamentais, mesmo ao usar ferramentas de alto nível. Esta experiência de aprendizagem inicial foi a génese do meu interesse em Kubernetes, uma tecnologia que teria um impacto significativo na minha trajectória profissional. Entender o Kubernetes, como qualquer outra ferramenta, requer uma compreensão firme da tecnologia subjacente.
O Kubernetes é complexo? Sim. É perfeito? Não. É adequado para todas as situações? Não. Mas a questão de saber se deve ou não usar o Kubernetes muitas vezes se resume à sua compreensão da tecnologia subjacente que torna o Kubernetes tão poderoso e como você pode usá-lo para gerenciar e proteger seu software.
Para aqueles que se perguntam "O que é Kubernetes?" ou talvez ainda não estejam familiarizados com o termo "Docker" (para além do tipo de calças) e a sua associação a contentores, permitam-me que explique.
As aplicações estão em constante evolução, com cada componente, desde a base de dados à linguagem de programação, a lançar frequentemente novas versões. Manter o controlo de várias versões de cada aplicação e de numerosas iterações de componentes de terceiros pode tornar-se uma tarefa difícil de gerir, especialmente quando se trata de versões mais antigas ou legadas sem suporte convencional. Mesmo as versões de software suportadas têm muitas dependências de instalação a nível do sistema e de terceiros que podem aumentar a complexidade da execução do software, quanto mais tentar utilizá-lo como um componente da sua aplicação.
Com o tempo, todo o software acaba por se tornar obsoleto e é substituído por versões mais recentes. O desafio consiste em executar software mais antigo quando necessário. Mesmo alterações aparentemente pequenas no software podem ter um enorme impacto nas aplicações modernas. Por exemplo, Python 2.7 (comparado com a versão mais recente Python 3.11) costumava ser embutido no Mac OS X da Apple. Python 2.7 tinha uma sintaxe estranha para saída de texto para a linha de comando: `print "this thing" ` ao invés da versão mais lógica de `print("this thing")` que está nas versões mais recentes de Python. Este pedaço de sintaxe pode quebrar toda uma aplicação Python por causa da falta de parênteses.
Embora a utilização de versões mais antigas de software possa ser impraticável, existem certamente situações em que é necessário executar software mais antigo. Mas como?
Podemos gastar o tempo a encontrar uma peça de hardware ou uma imagem de VM de um momento específico que nos permita executar um software antigo. Ou podemos recorrer aos contentores, um conceito pioneiro do Docker. Os contentores são aplicações autónomas com as suas dependências, que podem ser modificadas à medida das nossas necessidades. O seu ponto de venda único é a sua capacidade de transitar sem problemas de um sistema para outro.
Aqui está um exemplo de Dockerfile que usa Python 2.7 como o 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”]
```Este Dockerfile diz ao Docker o que é necessário para construir este novo container com código que existe em nossa máquina local e caminho local em `/src`. Dockerfiles podem se tornar muito mais complicados, mas este exemplo mostra como o uso do Docker pode ser fácil.
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 uma máquina, 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 quase qualquer linguagem ou ferramenta de código aberto.
No entanto, o problema surge quando queremos actualizar uma aplicação contentorizada, especialmente em produção. Localmente, atualizar um contêiner é simples. Deixamos de executar o contentor, reconstruímo-lo e voltamos a executá-lo. Na produção, no entanto, a atualização de um contêiner pode ser feita da mesma maneira, mas corremos o risco de um grande tempo de inatividade se a compilação falhar.
É aí que entra o Kubernetes. O Kubernetes ajuda a gerir o encaminhamento do tráfego para contentores específicos e supervisiona o número de contentores em execução num determinado momento. Se um contentor estiver a falhar, o Kubernetes facilita a reversão para versões anteriores com o mínimo ou nenhum tempo de inactividade.
A configuração para implantar 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. Através de `replicas: 3`, do nosso contentor declarado `hello-python:v1`, a nossa implementação está a executar 3 versões.
Agora, quando quisermos atualizar a versão implantada, podemos apenas alterar `hello-python:v1` para `hello-python:v2` e o Kubernetes atualizará graciosamente nosso aplicativo. E se algo der errado, ele irá reverter para `hello-py-deploy:v1`. O Kubernetes torna esse processo indolor e fácil de gerenciar. Manifestos podem ser facilmente controlados por versões com o git para que possamos ser muito granulares com nossas capacidades de rollback. O Kubernetes é parte integrante da 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.
Eu queria passar por cima de apenas alguns dos métodos que me levaram a descobrir como o Kubernetes poderia simplificar minhas implantaçõ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:
- Gerir repositórios git em plataformas auto-hospedadas ou na nuvem
- Implementar Python e Node.js aplicações através de VMs baseadas na nuvem com git
- Automatize a configuração e a implantação de VMs com Ansible
- Contentorizar e implementar aplicações com o Docker e o Docker Compose
- Executar contentores directamente em VMs sem orquestração
- Enviar e alojar contentores com o registo DockerHub
- Implantar aplicativos em contêineres no Kubernetes
- Implementar aplicações públicas e privadas em Kubernetes
- Configurar balanceadores de carga para tráfego HTTP e HTTPs
- Utilizar técnicas de CI/CD com o Github Actions e o acto alternativo de código aberto da Nectos
- e muito mais!
A implantação é o teste definitivo do seu software. Road to Kubernetes condensa quinze anos de aprendizados de implantação em um guia acessível e prático. Ele o leva 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 se mover entre opções de implantação e provedores de nuvem, e verá como é possível utilizar o Kubernetes para projetos de qualquer tamanho.
Para começar a compreender o Kubernetes, obtenha o MEAP de lançamento antecipado da Manning aqui.
Comentários