Arquivado | Implemente um aplicativo Python simples com o Kubernetes

Conteúdo arquivado

Data de arquivamento: 2021-01-07

Esse conteúdo não está mais sendo atualizado ou passando por manutenção. Esse conteúdo está sendo providenciado “da forma que está”. Considerando a rápida evolução da tecnologia, alguns conteúdos, passos, ou ilustrações podem ter mudado.

Quer experimentar o Kubernetes, mas não sabe por onde começar? A riqueza de recursos do Kubernetes pode dificultar a descoberta do básico para criar e implantar um aplicativo no Kubernetes. Neste tutorial, simplifico o desenvolvimento do Kubernetes e mostro como criar um aplicativo Python com o Docker e implantá-lo em um serviço do Kubernetes.

Objetivos do aprendizado

Após concluir este tutorial, você estará apto a:

  • Conteinerizar um aplicativo Flask usando o Docker e implementá-lo no IBM Cloud Kubernetes Service.

Pré-requisitos

Para concluir este tutorial, serão necessários os pré-requisitos a seguir:

Tempo estimado

Deve-se levar cerca de 45 minutos para concluir este tutorial.

Etapas

Crie um cluster Kubernetes

serviço aberto kubernetes

  • Clique em Criar cluster.

criar_cluster

  • Selecione a Região na qual você deseja implementar o cluster, digite um nome para o seu cluster e, em seguida, clique em Criar cluster.
  • Dependendo de sua conta (Paga ou Grátis), selecione o tipo de cluster apropriado.
  • Leva algum tempo para o cluster ficar pronto (cerca de 30 minutos).

região

  • Quando o cluster estiver pronto, clique no nome de seu cluster e você será redirecionado para uma nova página com informações sobre seu cluster e nó do trabalhador.

cluster_node worker

  • Clique na guia Nós do trabalhador para anotar o IP Público do cluster.

worker_nodes_tab

Conteinerize seu aplicativo Flask

  • Em seu diretório de projeto, crie um arquivo nomeado “Dockerfile”. Sugestão: nomeie seu arquivo exatamente como “Dockerfile” e nada mais.

dockerfile

Um “Dockerfile” é usado para indicar ao Docker uma imagem base, as configurações do Docker necessárias e uma lista de comandos que você gostaria de executar para preparar e iniciar seu novo container.

  • No arquivo, cole este código:

      FROM python:2.7
      LABEL maintainer="Kunal Malhotra, kunal.malhotra1@ibm.com"
      RUN apt-get update
      RUN mkdir /app
      WORKDIR /app
      COPY . /app
      RUN pip install -r requirements.txt
      EXPOSE 5000
      ENTRYPOINT [ "python" ]
      CMD [ "app.py" ]
    

Explicação e detalhamento do código do Dockerfile acima

  1. A primeira parte do código acima é:

     FROM python:2.7
    

    Como esse aplicativo Flask usa o Python 2.7, nós desejamos um ambiente que o suporte e que já o tenha instalado. Felizmente, o DockerHub possui uma imagem oficial que é instalada sobre o Ubuntu. Em uma linha, nós teremos uma imagem base do Ubuntu com Python 2.7, virtualenv e pip. Existem tons de imagens no DockerHub, mas se você deseja começar com uma nova imagem do Ubuntu e desenvolver por cima dela, é possível fazer isso.

  2. Vamos analisar a próxima parte do código:

     LABEL maintainer="Kunal Malhotra, kunal.malhotra1@ibm.com"
     RUN apt-get update
    
  3. Anote o mantenedor e atualize o índice do pacote Ubuntu. O comando é RUN, que é uma função que executa o comando que estiver depois dele.

     RUN mkdir /app
     WORKDIR /app
     COPY . /app
    
  4. Agora é hora de incluir o aplicativo Flask na imagem. Para simplificar, copie o aplicativo no diretório /app em nossa Imagem do Docker.

    WORKDIR basicamente é um cd no bash e COPY copia um determinado diretório no diretório fornecido em uma imagem. ADD é outro comando que faz a mesma coisa que COPY, mas ele também permite que você inclua um repositório a partir de uma URL. Portanto, se você deseja clonar seu repositório Git em vez de copiá-lo a partir de seu repositório local (para propósitos de preparação e produção), será possível usar isso. COPY, no entanto, deve ser usado na maior parte do tempo, a menos que você tenha uma URL.

  5. Agora que nós temos nosso repositório copiado na imagem, instalaremos todas as nossas dependências, que estão definidas na parte requirements.txt do código.

     RUN pip install --no-cache-dir -r requirements.txt
    
  6. Nós desejamos expor a porta(5000) na qual o aplicativo Flask é executado, portanto, usaremos EXPOSE.

     EXPOSE 5000
    
  7. ENTRYPOINT especifica o ponto de entrada de seu aplicativo.
     ENTRYPOINT [ "python" ]
     CMD [ "app.py" ]
    

Crie uma imagem a partir do Dockerfile

Abra o terminal e digite este comando para criar uma imagem a partir de seu Dockerfile: docker build -t <image_name>:<tag> . (observe o ponto para indicar que nós estamos em nosso diretório de nível superior de aplicativos). Por exemplo: docker build -t app:latest .

construir_image

Execute seu container localmente e teste

Após construir sua imagem com sucesso, digite: docker run -d -p 5000:5000 app

Esse comando criará um container que contém todo o código do aplicativo e as dependências da imagem e o executará localmente.

criar_container

criar_container

Envie a imagem por push para o IBM Cloud Registry

  1. Em seu painel da conta, acesse IBM Cloud Kubernetes Service.
  2. No menu de navegação à esquerda, selecione Repositórios privados.

    repositório privado

  3. Instale o plug-in Container Registry.

     ibmcloud plugin install container-registry -r "IBM Cloud"
    
  4. Efetue login em sua conta do IBM Cloud.

     ibmcloud login -a <cloud_foundary_end_point_for_the_region>
    
  5. Nomeie e crie seu namespace. Use esse namespace para o restante da Iniciação Rápida.

     ibmcloud cr namespace-add <namespace>
    
  6. Registre seu daemon do Docker local no IBM Cloud Container Registry.

     ibmcloud cr login
    
  7. Escolha um repositório e uma identificação pelos quais é possível identificar a imagem.

     docker tag <image_name> <region_url>/<namespace>/<image_name>:<tag>
    
  8. Envie a imagem por push.

     docker push <region_url>/<namespace>/<image_name>:<tag>
    

    docker_push

  9. Verifique se sua imagem está em seu registro privado.

     ibmcloud cr image-list
    

    verificar_imagem

Crie arquivos de configuração para o Kubernetes

Quando a imagem for transferida por upload com sucesso para o registro privado, acesse seu diretório de projeto e crie dois arquivos: deployment.yaml e service.yaml.

cria arquivos

  1. No arquivo deployment.yaml, cole este código:

     apiVersion: extensions/v1beta1
     kind: Deployment
     metadata:
       name: flask-node-deployment
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: flasknode
       template:
         metadata:
           labels:
             app: flasknode
         spec:
           containers:
           - name: flasknode
             image: registry.ng.bluemix.net/flask-node/app
             imagePullPolicy: Always
                 ports:
             - containerPort: 5000
    
  2. No arquivo service.yaml, cole este código:

     apiVersion: v1
     kind: Service
     metadata:
       name: flask-node-deployment
     spec:
           ports:
       - port: 5000
         targetPort: 5000
       selector:
         app: flasknode
    

Explicação e detalhamento do código do deployment.yaml

  1. Uma implementação denominada flask-node-deployment é criada, indicada pelo campo .metadata.name.
  2. A implementação cria um pod replicado, indicado pelo campo replicas.
  3. O campo do seletor define como a Implementação localiza quais Pods gerenciar. Nesse caso, nós simplesmente selecionamos uma etiqueta definida no modelo do Pod (app: flasknode). No entanto, regras de seleção mais sofisticadas são possíveis, contanto que o próprio modelo do Pod cumpra a regra.
  4. A especificação do modelo do pod, .template.spec, indica que os pods executam um container, flasknode, que executa a imagem de registro privado do aplicativo.
  5. A implementação abre a porta 5000 para uso pelos Pods.

Explicação e detalhamento do código do service.yaml

  1. A especificação do service.yaml criará um novo objeto de serviço nomeado flask-node-deployment que visa à porta TCP 5000 em qualquer Pod com a etiqueta “app=flasknode”. Esse Serviço também terá um endereço IP designado (às vezes chamado de IP do cluster), que é usado pelos proxies de serviço (veja abaixo). O seletor do Serviço será avaliado continuamente e os resultados serão POSTados em um objeto Endpoints também nomeado flask-node-deployment.

  2. Observe que um serviço pode mapear uma porta de entrada para qualquer targetPort. Por padrão, a targetPort será configurada com o mesmo valor que o campo da porta. Talvez, o mais interessante é que targetPort pode ser uma sequência, referindo-se ao nome de uma porta nos Pods de back-end. O número da porta real designado a esse nome pode ser diferente em cada Pod de back-end. Isso oferece muita flexibilidade para implementar e desenvolver seus Serviços. Por exemplo, é possível mudar o número da porta que os pods expõem na próxima versão de seu software de back-end, sem interromper os clientes.

Implemente seu aplicativo para o Kubernetes

  1. Especifique a região do IBM Cloud Kubernetes Service na qual você deseja trabalhar.

     ibmcloud cs region-set us-south
    
  2. Configure o contexto para o cluster em sua CLI.

    a. Obtenha o comando para configurar a variável de ambiente e faça download dos arquivos de configuração do Kubernetes.

     ibmcloud cs cluster-config cluster_kunal
    

    b. Configure a variável de ambiente KUBECONFIG. Copie a saída do comando anterior e cole-a em seu terminal. A saída de comando deve ser semelhante ao seguinte.

    > export KUBECONFIG=/Users/$USER/.bluemix/plugins/container-service/clusters/< cluster_name >/< cluster_configuration_file.yaml>
    
  3. Verifique se é possível conectar-se ao seu cluster listando seus nós do trabalhador.

     kubectl get nodes
    
  4. Crie a implementação.

     kubectl create -f deployment.yaml
    

    criar_serviço

  5. Crie o serviço.

     kubectl create -f service.yaml
    

    criar_deployment

  6. Consulte o painel do Kubernetes a partir da página de visão geral do IBM Kubernetes Service.

    criar_serviço

  7. Por fim, acesse seu navegador e efetue ping no IP Público de seu nó do trabalhador.

    pingar ip_público

Recursos e referências

  1. Documentação Kubernetes
  2. Implemente um aplicativo de microsserviços no IBM Cloud usando o Kubernetes
  3. Tutorial: implementando aplicativos nos clusters