Como implantar aplicativo Python no Kubernetes com Okteto

Okteto é uma plataforma de desenvolvimento usada para agilizar o processo de desenvolvimento de aplicações Kubernetes. Ele permite que os desenvolvedores criem e testem seus aplicativos diretamente em clusters Kubernetes, sem configurar ambientes de desenvolvimento locais complexos. Okteto permite atualizações ao vivo para aplicativos executados em clusters Kubernetes, permitindo que os desenvolvedores vejam suas alterações de código refletidas em tempo real, sem a necessidade de reconstruir ou reimplantar seus aplicativos.

Neste tutorial, você criará um aplicativo Python e o implantará no Kubernetes usando Okteto.

Pré-requisitos

Antes de começar este tutorial, você precisará do seguinte:

Um cluster Kubernetes 1.28. Neste tutorial, a configuração usará um cluster DigitalOcean Kubernetes com pelo menos 3 nós (4CPUs e 16GBs cada)
kubectl instalado e configurado para se comunicar com seu cluster.
Uma conta Docker Hub.
Docker em execução na sua máquina local.
Uma licença é obrigatória para usar o Okteto. Inscreva-se no teste gratuito de 30 dias do Okteto para obter uma chave de licença.
O gerenciador de pacotes Helm está instalado em sua máquina local. Para fazer isso, conclua a Etapa 1 do tutorial Como instalar software em clusters Kubernetes com o Helm 3 Package Manager.
Um nome de domínio totalmente registrado apontado para o Load Balancer usado pelo Nginx Ingress. Você precisará criar um A gravar com o nome * e IP do balanceador de carga.

Passo 1 – Crie um aplicativo Python

Primeiro, você precisa garantir que o Python esteja instalado em seu sistema Ubuntu. Você pode verificar isso abrindo um terminal e digitando:

python3 --version

Se o Python estiver instalado, este comando exibirá a versão do Python. Caso contrário, você pode instalá-lo usando o seguinte comando:

sudo apt install python3 python3-venv python3-pip -y

Em seguida, crie um diretório para armazenar o código do seu aplicativo e outras configurações.

mkdir my-app

Em seguida, navegue até o diretório do seu aplicativo e crie um ambiente virtual para isolar as dependências do seu projeto.

cd my-apppython3 -m venv python-env

Em seguida, ative o ambiente virtual usando o seguinte comando.

source python-env/bin/activate

A seguir, crie um novo arquivo Python para seu aplicativo. Por exemplo, crie um simples app.py arquivo:

nano app.py

Adicione o seguinte código:

from flask import Flaskapp = Flask(__name__)@app.route('/')def hello():    return "Hello, This is a simple Python App!"if __name__ == '__main__':    app.run(debug=True, host='0.0.0.0')

Em seguida, instale a estrutura da web Flask.

pip install flask

Agora, execute seu aplicativo Python usando o seguinte comando.

python3 app.py

Você verá a seguinte saída.

Output

 * Running on all addresses (0.0.0.0) * Running on http://127.0.0.1:5000 * Running on http://172.20.10.2:5000Press CTRL+C to quit * Restarting with stat * Debugger is active! * Debugger PIN: 311-959-468

Agora que o aplicativo Flask está sendo executado localmente e você pode verificá-lo usando curl:

curl -X GET -H "Content-Type: application/json" http://localhost:5000

Você deve receber a seguinte resposta do aplicativo Flask.

Output

Hello, This is a simple Python App!

Quando terminar de trabalhar no seu projeto, você pode desativar o ambiente virtual executando:

deactivate

Neste ponto, você criou um aplicativo Python e o testou localmente.

Etapa 2 – Dockerizar aplicativo Python

Dockerizar um aplicativo Python envolve a criação de uma imagem Docker que contém o ambiente Python e as dependências necessárias para executar o aplicativo.

Primeiro, crie um arquivo chamado Dockerfile no diretório raiz do seu aplicativo Python.

nano Dockerfile

Adicione o seguinte conteúdo:

# Use an official Python runtime as a parent imageFROM python:3.8-slim# Set the working directory in the containerWORKDIR /app# Copy the current directory contents into the container at /appADD . /app# Install any needed dependencies specified in requirements.txtRUN pip install flask# Make port 5000 available to the world outside this containerEXPOSE 5000# Define environment variableENV NAME DockerizedPythonApp# Run app.py when the container launchesCMD ["python3", "./app.py"]

Neste Dockerfile:

FROM python:3.8-slim: especifica a imagem base a ser usada. Você está usando uma imagem oficial do Python com o Python 3.8 instalado.
WORKDIR /app: Define o diretório de trabalho dentro do contêiner como /app.
ADD . /app: Copia o conteúdo do diretório atual para o contêiner /app diretório.
RUN pip install flask: Instala a estrutura Flask.
EXPOSE 5000: Expõe porta 5000 para permitir conexões de entrada.
CMD ["python3", "app.py"]: especifica o comando a ser executado quando o contêiner for iniciado. Neste caso, ele é executado app.py.

Agora, execute o seguinte comando para construir a imagem com base nas instruções do seu Dockerfile.

docker build -t my-app .

Depois de construir a imagem Docker, você pode executar seu aplicativo em um contêiner usando a imagem construída:

docker run -dit -p 5000:5000 my-app:latest

Este comando executa um contêiner do my-app imagem e mapeia a porta do contêiner para uma porta host 5000.

Você pode verificar o contêiner do seu aplicativo em execução usando o docker ps comando.

docker ps

A saída será:

Output

CONTAINER ID   IMAGE           COMMAND              CREATED         STATUS         PORTS                                       NAMES761c54c77411   my-app:latest   "python3 ./app.py"   3 seconds ago   Up 3 seconds   0.0.0.0:5000->5000/tcp, :::5000->5000/tcp   pedantic_wescoff

Abra um navegador da web ou use curl para acessar o aplicativo usando a URL http://your-server-ip:5000. Você deve ver a mensagem Hello, This is a simple Python App! indicando que seu aplicativo Python está sendo executado dentro do contêiner Docker.

Até agora, você encaixou com sucesso seu aplicativo Python.

Etapa 3 – Enviar imagem do Docker do Python para o registro do DockerHub

Primeiro, você precisa ter uma conta DockerHub. Se não tiver um, você pode criá-lo no site do DockerHub.

Use o docker login comando para fazer login no Docker Hub. Você será solicitado a inserir seu nome de usuário e senha do Docker Hub.

docker login

A saída deste comando será:

Output

Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to https://hub.docker.com to create one.Username: username@gmail.comPassword: WARNING! Your password will be stored unencrypted in /root/.docker/config.json.Configure a credential helper to remove this warning. Seehttps://docs.docker.com/engine/reference/commandline/login/#credentials-storeLogin Succeeded

Antes de enviar a imagem para o Docker Hub, você também precisa marcá-la com seu nome de usuário do Docker Hub e o nome do repositório desejado.

docker tag my-app yourusername/my-app:latest

Agora você pode enviar sua imagem Docker para Docker Hub usando o docker push comando.

docker push yourusername/my-app:latest

Depois de enviar a imagem, você pode verificar se ela está disponível no Docker Hub procurando por ela usando a CLI do Docker Hub.

docker search yourusername/my-app

A imagem Docker do seu aplicativo Python agora está disponível no Docker Hub e pode ser extraída por outras pessoas ou implantada em vários ambientes.

Etapa 4 – Crie manifestos do Kubernetes para implantar o aplicativo Python

Agora, você precisará criar um arquivo de manifestos do Kubernetes usando Okteto para definir os recursos de implantação, serviço e entrada para um aplicativo chamado my-app.

nano k8s.yaml

Adicione a seguinte configuração ao arquivo.

apiVersion: apps/v1kind: Deploymentmetadata:  name: my-appspec:  selector:    matchLabels:      app: my-app  template:    metadata:      labels:        app: my-app    spec:      containers:      - image: yourusername/my-app        name: my-app---apiVersion: v1kind: Servicemetadata:  name: my-appspec:  type: ClusterIP  ports:  - name: "my-app"    port: 5000  selector:    app: my-app---apiVersion: networking.k8s.io/v1kind: Ingressmetadata:  name: my-app  annotations:    dev.okteto.com/generate-host: my-appspec:  rules:    - http:        paths:          - backend:              service:                name: my-app                port:                  number: 5000            path: /            pathType: ImplementationSpecific

O arquivo acima implanta um aplicativo chamado my-app usando Okteto, expõe-no internamente através de um serviço ClusterIP na porta 5000e configura um recurso do Ingress para rotear o tráfego HTTP para o aplicativo. Anotações específicas do Okteto são usadas para habilitar certos recursos fornecidos pelo Okteto, como a geração automática de nomes de host.

Etapa 5 – Instale o Okteto usando o Helm

Primeiro, você precisa adicionar o repositório Okteto Helm ao seu cliente Helm.

helm repo add okteto https://charts.okteto.com

Depois de adicionar o repositório Okteto Helm, você deve atualizar seus repositórios Helm para garantir que tenha as informações mais recentes sobre os gráficos disponíveis:

helm repo update

A seguir, crie um config.yaml para Okteto.

nano config.yaml

Adicione sua chave de licença, subdomínio e outras configurações do Okteto conforme mostrado abaixo:

license: INSERTYOURKEYHEREsubdomain: okteto.example.combuildkit:  persistence:    enabled: trueregistry:  storage:    filesystem:      persistence:        enabled: true

Observação:Substitua a chave de licença pela sua chave de licença válida do Okteto e okteto.example.com com seu nome de domínio.

Agora, instale a versão mais recente do Okteto usando o config.yaml arquivo de configuração.

helm install okteto okteto/okteto -f config.yaml --namespace okteto --create-namespace

Assim que o Okteto estiver instalado, você obterá a seguinte saída.

Output

NAME: oktetoLAST DEPLOYED: Tue Mar 12 20:27:21 2024NAMESPACE: oktetoSTATUS: deployedREVISION: 1TEST SUITE: NoneNOTES:Congratulations! Okteto is successfully installed!Follow these steps to complete your domain configuration:1. Create a wildcard A record "*.okteto.example.com", pointing it to the Okteto NGINX ingress controller External-IP:   $ kubectl get service -l=app.kubernetes.io/name=ingress-nginx,app.kubernetes.io/component=controller --namespace=okteto2. Access your Okteto instance at `https://okteto.okteto.example.com/login#token=88f8cc11`

Observação:Lembre-se dos tokens de acesso pessoal 88f8cc11 da saída acima. Você precisará dele para autenticar o Okteto.

Aguarde um pouco e busque o endereço IP que a DigitalOcean alocou dinamicamente para o NGINX Ingress que você acabou de instalar e configurar como parte do Okteto:

kubectl get service -l=app.kubernetes.io/name=ingress-nginx,app.kubernetes.io/component=controller --namespace=okteto

Você verá a seguinte saída.

Output

NAME                              TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)                      AGEokteto-ingress-nginx-controller   LoadBalancer   10.101.31.239   45.76.14.191   80:31150/TCP,443:31793/TCP   3m21s

Você precisa levar o EXTERNAL-IP endereço e adicione-o ao DNS do domínio que você escolheu usar. Isto é feito criando um A gravar com o nome *.

Agora, abra seu navegador e acesse sua instância do Okteto em https://okteto.okteto.example.com/login#token=88f8cc11.

Etapa 6 – Instalar e configurar a CLI do Okteto

O Okteto CLI é uma ferramenta de linha de comando de código aberto que permite desenvolver seus aplicativos diretamente no Kubernetes.

Você pode instalar a CLI Okteto no Linux e macOS usando curl. Abra seu terminal e execute o seguinte comando:

sudo curl https://get.okteto.com -sSfL | sh

Assim que a instalação for concluída, você pode verificar se a CLI do Okteto está instalada corretamente executando o seguinte comando:

okteto version

Este comando exibirá a versão do Okteto CLI instalada em seu sistema.

Output

okteto version 2.25.2

Em seguida, você precisará usar seus tokens de acesso pessoal para autenticar com a CLI do Okteto.

okteto context use https://okteto.okteto.example.com --token 88f8cc11 --insecure-skip-tls-verify

Sua saída será:

Output

 ✓  Using okteto-admin @ okteto.okteto.example.com

Em seguida, execute o seguinte comando para verificar se sua CLI Okteto está configurada.

okteto context list

Isso fornece a seguinte saída:

Output

Name                                      Namespace     Builder                                 Registryhttps://okteto.okteto.example.com *      okteto-admin  tcp://buildkit.okteto.example.com:443  registry.okteto.example.comvke-4b7aaaa6-78fa-4a19-9fb3-cf7b8c1ec678  default       docker                                  -

Passo 7 – Crie seu Manifesto Okteto

Para começar a desenvolver a aplicação Python, você precisará criar um arquivo de manifesto Okteto e definir a configuração do seu ambiente de desenvolvimento.

Vamos criar um okteto.yaml arquivo para um aplicativo Python simples.

nano okteto.yaml

Adicione a seguinte configuração.

deploy:  - kubectl apply -f k8s.yamldev:  my-app:    command: bash    environment:      - FLASK_ENV=development    sync:      - .:/app    reverse:      - 9000:9000    volumes:      - /root/.cache/pip

No arquivo acima,

deploy: esta seção define a configuração de implantação. Quando você corre okteto up ou okteto deployOkteto executará o kubectl apply -f k8s.yaml comando para implantar os recursos do Kubernetes definidos no k8s.yaml arquivo. Isso permite especificar sua configuração de implantação separadamente da configuração do ambiente de desenvolvimento.
command: bash: especifica o comando a ser executado quando o ambiente de desenvolvimento for iniciado.
environment: especifica variáveis de ambiente a serem definidas no ambiente de desenvolvimento. Neste caso, ele define FLASK_ENV para o desenvolvimento.
sync: especifica pastas para sincronizar entre sua máquina local e o ambiente de desenvolvimento. Ele sincroniza o diretório atual (.) com /app dentro do ambiente de desenvolvimento.
reverse: especifica regras de encaminhamento de porta para expor portas do ambiente de desenvolvimento para sua máquina local. Neste caso, ele encaminha a porta 9000 do ambiente de desenvolvimento ao porto 9000 em sua máquina local.
volumes: especifica volumes adicionais para montar no ambiente de desenvolvimento. Neste caso, ele monta o /root/.cache/pip diretório, que pode ser usado para armazenar pacotes pip em cache, no ambiente de desenvolvimento.

Agora, implante seu aplicativo Python no cluster Kubernetes usando o comando a seguir.

okteto deploy

Após a implantação bem-sucedida, você verá a seguinte saída.

Output

deployment.apps/my-app createdservice/my-app createdingress.networking.k8s.io/my-app created i  There are no available endpoints for 'Okteto'.    Follow this link to know more about how to create public endpoints for your application:    https://www.okteto.com/docs/cloud/ssl/ ✓  Development environment 'Okteto' successfully deployed i  Run 'okteto up' to activate your development container

Em seguida, volte ao seu navegador e atualize o painel do Okteto. Você verá seu aplicativo implantado:

Você também pode acessar seu aplicativo Python usando o URL https://my-app-okteto-admin.okteto.example.com.

Etapa 8 – Desenvolva um aplicativo Python diretamente no Kubernetes

Nesta seção, você usará o okteto up comando para implantar um aplicativo Python diretamente no Kubernetes. Este comando sincronizará seu código local com o ambiente de desenvolvimento. Você pode modificar o código usando seu IDE preferido ou editor de texto em sua máquina local, e as alterações serão sincronizadas automaticamente com o ambiente de desenvolvimento no Kubernetes.

Vamos iniciar o ambiente de desenvolvimento usando Okteto:

okteto up

Este comando criará um ambiente de desenvolvimento baseado nas configurações especificadas no okteto.yaml arquivo.

Output

 i  Using okteto-admin @ okteto.okteto.example.com as context i  'Okteto' was already deployed. To redeploy run 'okteto deploy' or 'okteto up --deploy' i  Build section is not defined in your okteto manifest ✓  Persistent volume successfully attached ✓  Images successfully pulled ✓  Files synchronized    Context:   okteto.okteto.example.com    Namespace: okteto-admin    Name:      my-app    Reverse:   9000 <- 9000root@my-app-okteto-7767588c8d-ndzj7:/app#

Em seguida, execute seu aplicativo Python:

python3 app.py

Você verá a seguinte saída.

Output

 * Serving Flask app 'app' * Debug mode: onWARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on all addresses (0.0.0.0) * Running on http://127.0.0.1:5000 * Running on http://10.244.97.92:5000Press CTRL+C to quit * Restarting with stat * Debugger is active! * Debugger PIN: 126-620-675

Agora, edite seu app.py arquivo do aplicativo:

nano app.py

Modifique a seguinte linha:

    return "Hello, This is a simple Python App Deployed on Kubernetes"

Salve e feche o arquivo. Okteto detectará automaticamente as alterações de código e as aplicará instantaneamente ao Kubernetes.

Volte para o seu navegador e recarregue a página do seu aplicativo Python. Você verá seu aplicativo modificado na tela a seguir.

Conclusão

Neste tutorial, você criou um aplicativo Python básico e o implantou no cluster Kubernetes usando Okteto. A capacidade do Okteto de sincronizar alterações de código local com o ambiente de desenvolvimento em tempo real permite rápidas iterações de desenvolvimento e feedback imediato sobre alterações de código. No geral, o Okteto capacita os desenvolvedores a se concentrarem na construção de aplicativos Python de alta qualidade sem se preocupar com as complexidades da infraestrutura do Kubernetes.

O autor selecionou a FreeBSD Foundation para receber uma doação como parte do programa Write for DOnations.