Pesquisa de site

Como implantar aplicativo Python no Kubernetes com Okteto

Introdução

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 16GB 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 registro A com o nome * e IP do Load Balancer.

Etapa 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-app
python3 -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 arquivo app.py simples:

nano app.py

Adicione o seguinte código:

from flask import Flask

app = 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.

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

Agora que o aplicativo Flask está sendo executado localmente, 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.

Hello, This is a simple Python App!

Quando terminar de trabalhar em 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 image
FROM python:3.8-slim

# Set the working directory in the container
WORKDIR /app

# Copy the current directory contents into the container at /app
ADD . /app

# Install any needed dependencies specified in requirements.txt
RUN pip install flask

# Make port 5000 available to the world outside this container
EXPOSE 5000

# Define environment variable
ENV NAME DockerizedPythonApp

# Run app.py when the container launches
CMD ["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.
  • ADICIONAR. /app: Copia o conteúdo do diretório atual para o diretório /app do contêiner.
  • RUN pip install flask: Instala a estrutura Flask.
  • EXPOSE 5000: Expõe a 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 executa 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 a partir da imagem my-app e mapeia a porta do contêiner para uma porta host 5000.

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

docker ps

A saída será:

CONTAINER ID   IMAGE           COMMAND              CREATED         STATUS         PORTS                                       NAMES
761c54c77411   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ê deverá 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 comando docker login 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á:

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.com
Password: 
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login 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 o Docker Hub usando o comando docker push.

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/v1
kind: Deployment
metadata:
  name: my-app
spec:
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - image: yourusername/my-app
        name: my-app

---

apiVersion: v1
kind: Service
metadata:
  name: my-app
spec:
  type: ClusterIP
  ports:
  - name: "my-app"
    port: 5000
  selector:
    app: my-app

---

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-app
  annotations:
    dev.okteto.com/generate-host: my-app
spec:
  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, o expõe internamente por meio de um serviço ClusterIP na porta 5000 e configura um recurso 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

Em seguida, 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: INSERTYOURKEYHERE
subdomain: okteto.example.com

buildkit:
  persistence:
    enabled: true

registry:
  storage:
    filesystem:
      persistence:
        enabled: true

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

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

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

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

NAME: okteto
LAST DEPLOYED: Tue Mar 12 20:27:21 2024
NAMESPACE: okteto
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
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=okteto

2. Access your Okteto instance at `https://okteto.okteto.example.com/login#token=88f8cc11`

Nota: 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.

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

Você precisa pegar o endereço EXTERNAL-IP e adicioná-lo ao DNS do domínio que você escolheu usar. Isso é feito criando um registro A 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 do Okteto no Linux e no 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.

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á:

 ✓  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:

Name                                      Namespace     Builder                                 Registry
https://okteto.okteto.example.com *      okteto-admin  tcp://buildkit.okteto.example.com:443  registry.okteto.example.com
vke-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 arquivo okteto.yaml para uma aplicação Python simples.

nano okteto.yaml

Adicione a seguinte configuração.

deploy:
  - kubectl apply -f k8s.yaml

dev:
  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. Ao executar okteto up ou okteto deploy, o Okteto executará o comando kubectl apply -f k8s.yaml para implantar os recursos do Kubernetes definidos no arquivo arquivo k8s.yaml. 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.
  • ambiente: especifica variáveis de ambiente a serem definidas no ambiente de desenvolvimento. Neste caso, ele define FLASK_ENV para 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 para a porta 9000 na sua máquina local.
  • volumes: especifica volumes adicionais para montar no ambiente de desenvolvimento. Nesse caso, ele monta o diretório /root/.cache/pip, 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.

deployment.apps/my-app created
service/my-app created
ingress.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 comando okteto up 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 arquivo okteto.yaml.

 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 <- 9000
root@my-app-okteto-7767588c8d-ndzj7:/app#

Em seguida, execute seu aplicativo Python:

python3 app.py

Você verá a seguinte saída.

 * Serving Flask app 'app'
 * Debug mode: on
WARNING: 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:5000
Press CTRL+C to quit
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 126-620-675

Agora, edite o arquivo do aplicativo app.py:

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 iterações rápidas 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 Fundação FreeBSD para receber uma doação como parte do programa Write for DOnations.