Aplicativo da web escalável no Kubernetes

Este tutorial pode incorrer em custos. Use o Estimador de custos para gerar uma estimativa do custo baseada em seu uso projetado.

Este tutorial descreve como executar um aplicativo web localmente em um contêiner e como implementá-lo em um cluster de Kubernetes criado com o Kubernetes Service. Como uma etapa opcional, você pode criar uma imagem de contêiner e enviar a imagem para um registro privado. Além disso, você aprenderá como ligar um subdomínio customizado, monitorar o funcionamento do ambiente e escalar o aplicativo.

Os contêineres são uma maneira padrão de empacotar apps e todas as suas dependências para que seja possível mover facilmente os apps entre ambientes. Ao contrário de máquinas virtuais, os contêineres não empacotam o sistema operacional. Somente o código de app, o tempo de execução, as ferramentas de sistema, as bibliotecas e as configurações são empacotados dentro de contêineres. Os contêineres são mais leves, móveis e eficientes do que máquinas virtuais.

Objetivos

  • Implementar um aplicativo web no cluster de Kubernetes.
  • Ligar um subdomínio customizado.
  • Monitorar os logs e o funcionamento do cluster.
  • Escalar pods do Kubernetes.

Arquitetura
Diagrama de arquitetura

  1. Um desenvolvedor faz download ou clona um aplicativo da Web de amostra.
  2. Opcionalmente, construa o aplicativo para produzir uma imagem de contêiner.
  3. Opcionalmente, a imagem é enviada por push para um namespace no IBM Cloud Container Registry.
  4. O aplicativo é implementado em um cluster Kubernetes.
  5. Os usuários acessam o aplicativo.

Antes de Iniciar

Este tutorial requer:

  • CLI do IBM Cloud,
    • Plug-in do IBM Cloud Kubernetes Service (kubernetes-service),
  • kubectl para interagir com clusters Kubernetes,
  • Helm 3 para implementar gráficos.

Você encontrará instruções para fazer download e instalar essas ferramentas para o seu ambiente operacional no guia Introdução aos tutoriais.

Para evitar a instalação dessas ferramentas, é possível usar o Cloud Shell por meio do console do IBM Cloud.

Além disso:

  • Você precisará de uma instância do Secrets Manager. Com o Secrets Manager, é possível criar, arrendar e gerenciar centralmente os segredos que são usados nos serviços IBM Cloud ou em seus aplicativos integrados customizados. Os segredos são armazenados em uma instância dedicada do Secrets Manager e é possível usar recursos integrados para monitorar a expiração, programar ou girar manualmente os seus segredos. Neste tutorial, você usará um Kubernetes Operator para recuperar um certificado TLS de Secrets Manager e injetá-lo em um segredo Kubernetes. É possível usar uma instância existente se você já tem um ou criar um novo seguindo as etapas descritas em Criando uma instância do serviço Secrets Manager.
  • Opcionalmente, configure um namespace de registro. Ele será necessário apenas se você construir sua própria imagem de contêiner customizada..
  • Entenda o básico de Kubernetes.

Ative a comunicação de serviço a serviço com o Secrets Manager

A integração do Secrets Manager com o cluster do IBM Cloud Kubernetes Service requer autorização de comunicação de serviço para serviço. Siga estas etapas para configurar a autorização. Para obter mais informações, consulte Integrações para Secrets Manager..

  1. No console IBM Cloud, clique em Gerenciar > Acesso (IAM).
  2. Clique em Autorizações.
  3. Clique em Criar.
  4. Na lista Serviço de origem, selecione Kubernetes Service.
  5. Selecione a opção para definir o escopo do acesso a Todos os recursos
  6. Na lista de serviços de destino, selecione Secrets Manager.
  7. Selecione a opção para definir o escopo do acesso a Todos os recursos
  8. Na seção Acesso ao serviço, marque a opção Gerente.
  9. Clique em Autorizar.

Criar um cluster Kubernetes

O IBM Cloud Kubernetes Service é uma oferta gerenciada para criar seu próprio cluster Kubernetes de hosts de computação para implementar e gerenciar aplicativos em contêineres no IBM Cloud. Um cluster mínimo com uma (1) zona, um (1) nó do trabalhador e o menor tamanho disponível (Tipo) é suficiente para este tutorial.

  1. Abra os clusters Kubernetes e clique em Criar cluster.

  2. Crie um cluster em sua escolha de Infraestrutura

    • As etapas a seguir serão se você selecionar o VPC para Kubernetes na infraestrutura do VPC É necessário criar um VPC e uma ou mais sub-redes antes de criar o cluster Kubernetes. Consulte a documentação Criando clusters VPC para obter mais detalhes.

      1. Clique em Criar VPC..
      2. Na seção Local, selecione Geografia e Região, por exemplo Europe e London.
      3. Digite um nome para sua VPC, selecione um grupo de recursos e, opcionalmente, adicione tags para organizar seus recursos.
      4. Desmarque Permitir SSH e Permitir ping no Grupo de segurança padrão.
      5. Desmarque a opção Criar sub-rede em cada zona.
      6. Clique em Criar.
      7. Em Zonas do trabalhador e sub-redes e desmarque as duas zonas para as qual a sub-rede não foi criada.
      8. Configure os Nós do trabalhador por zona como 1 e clique em Mudar tipo para explorar e mudar para o tamanho do nó do trabalhador de sua escolha
      9. Em Ingresso, ative Gerenciamento de segredos do Ingress e selecione sua instância existente do Secrets Manager.
      10. Insira um Nome do cluster e selecione o mesmo Grupo de recursos usado para o VPC.
      11. A criação de log ou o monitoramento não são necessários neste tutorial, desative essas opções e clique em Criar.
      12. Enquanto você espera que o cluster se torne ativo, conecte um gateway público à VPC Navegue para Nuvens privadas virtuais.
      13. Clique no nome para o VPC usado pelo cluster e role para baixo até a seção de sub-redes
      14. Clique no nome da sub-rede criada anteriormente e na seção Public Gateway, clique em Desconectado para mudar o estado para Conectado.

    • As etapas a seguir são se você selecionar Clássico para Kubernetes na infraestrutura Clássica Consulte a documentação Criando um cluster clássico padrão para obter mais detalhes.

      1. Na seção Local, selecione uma Geografia, multizona Disponibilidade e Metro por exemplo Europe e London.
      2. Em Zonas e VLANs do trabalhador, desmarque todas as zonas, exceto uma delas
      3. Configure os Nós do trabalhador por zona como 1 e clique em Mudar tipo para explorar e mudar para o tamanho do nó do trabalhador de sua escolha
      4. Em Terminal em Serviço Principal e selecione Terminais privados e públicos.
      5. Em Ingresso, ative Gerenciamento de segredos do Ingress e selecione sua instância existente do Secrets Manager.
      6. Insira um Nome do cluster e selecione o Grupo de recursos no qual criar esses recursos.
      7. A criação de log ou o monitoramento não são necessários neste tutorial, desative essas opções e clique em Criar.

Clonar um aplicativo de amostra

Nesta seção, você clonará um repositório GitHub com um aplicativo de amostra simples NodeJS Helm com uma página de destino e dois endpoints para começar. Você sempre pode estender o aplicativo de amostra com base em seus requisitos.

  1. Em um terminal, execute o comando abaixo para clonar o repositório GitHub:
    git clone https://github.com/IBM-Cloud/kubernetes-node-app
  2. Vá para o diretório do aplicativo:
    cd kubernetes-node-app

Esse código de aplicativo de amostra contém todos os arquivos de configuração necessários para o desenvolvimento local e a implantação no Kubernetes.

Implementar o aplicativo no cluster usando o gráfico do Helm

Implementar o aplicativo com Helm 3

A imagem do contêiner para o aplicativo já foi criada e enviada para um registro público no IBM Cloud Container Registry. Nesta seção, você implantará o aplicativo de amostra usando Helm. O Helm ajuda você a gerenciar aplicativos Kubernetes por meio de Gráficos do Helm, o que ajuda a definir, instalar e fazer upgrade até mesmo do aplicativo Kubernetes mais complexo.

Observação: se quiser criar e enviar o aplicativo para o seu próprio registro de contêiner, use a CLI Docker para fazer isso. O Dockerfile é fornecido no repositório e as imagens podem ser enviadas para o IBM Cloud Container Registry ou qualquer outro registro de contêiner.

  1. Defina uma variável de ambiente chamada MYAPP e defina o nome do aplicativo substituindo o espaço reservado por suas iniciais:

    export MYAPP=<your-initials>kubenodeapp

  2. Identifique seu cluster:

    ibmcloud ks cluster ls

  3. Inicialize a variável com o nome do cluster:

    export MYCLUSTER=<CLUSTER_NAME>

  4. Inicialize o ambiente kubectl cli:

    ibmcloud ks cluster config --cluster $MYCLUSTER

    Certise-se de que a CLI esteja configurada para a região e grupo de recursos onde o seu criou seu cluster usando ibmcloud target -r <region> -g <resource_group>. Para obter mais informações sobre a obtenção de acesso ao seu cluster e para configurar a CLI para executar comandos kubectl, verifique a seção Configuração da CLI

  5. É possível usar o namespace default do Kubernetes ou criar um novo namespace para este aplicativo.

    1. Se você quiser usar o namespace default Kubernetes, execute o comando abaixo para definir uma variável de ambiente:
      export KUBERNETES_NAMESPACE=default
    2. Se você deseja criar um novo namespace do Kubernetes, siga as etapas mencionadas nas seções Copiando um segredo de extração de imagem existente e Armazenando o segredo de extração de imagem na conta de serviço do Kubernetes para o namespace selecionado da documentação de serviço do Kubernetes. Depois de concluído, execute o comando abaixo:
      export KUBERNETES_NAMESPACE=<KUBERNETES_NAMESPACE_NAME>

  6. Mude para o diretório de gráficos no diretório do aplicativo de amostra:

    cd chart/kubernetesnodeapp

  7. Instalar o gráfico Helm:

    helm install $MYAPP --namespace $KUBERNETES_NAMESPACE . --set image.repository=icr.io/solution-tutorials/tutorial-scalable-webapp-kubernetes

  8. Altere novamente para o diretório do aplicativo de amostra:

    cd ../..

Visualizar o aplicativo

  1. Liste os serviços do Kubernetes no namespace:
    kubectl get services -n $KUBERNETES_NAMESPACE
  2. Lista os pods Kubernetes no namespace:
    kubectl get pods -n $KUBERNETES_NAMESPACE

Usar o domínio fornecido pela IBM para seu cluster

Os clusters vêm com um domínio IBM. Isso fornece a você uma melhor opção para expor aplicativos com uma URL adequada e nas portas HTTP/S padrão.

Use o Ingresso para configurar a conexão de entrada de cluster para o serviço.

Ingresso
Ingresso

  1. Identifique o seu IBM-fornecido Ingress subdomain e Ingress secret:

    ibmcloud ks cluster get --cluster $MYCLUSTER

    para procurar

    Ingress subdomain: mycluster.us-south.containers.appdomain.cloud
Ingress secret:    mycluster

  2. Definir variável de ambiente INGRESS_SUBDOMAIN para manter o valor do subdomínio Ingresso:

    export INGRESS_SUBDOMAIN=<INGRESS_SUBDOMAIN>

  3. Definir variável de ambiente INGRESS_SECRET para manter o valor do segredo do Ingresso:

    export INGRESS_SECRET=<INGRESS_SECRET>

  4. No diretório do aplicativo de amostra, execute o comando bash abaixo para criar um arquivo Ingress ingress-ibmsubdomain.yaml apontando para o domínio IBM com suporte para HTTP e HTTPS:

    ./ingress.sh ibmsubdomain_https

    O arquivo é gerado a partir de um arquivo de modelo ingress-ibmsubdomain-template.yaml na pasta yaml-templates, substituindo todos os valores contidos nos espaços reservados ( $ ) pelos valores apropriados das variáveis de ambiente.

  5. Implemente o Ingresso:

    kubectl apply -f ingress-ibmsubdomain.yaml

  6. Abra seu aplicativo em um navegador em https://<myapp>.<ingress-subdomain>/ ou execute o comando abaixo para ver a saída HTTP:

    curl -I https://$MYAPP.$INGRESS_SUBDOMAIN

Use seu próprio subdomínio customizado

Esta seção requer que você tenha um domínio customizado próprio. Será necessário criar um registro CNAME apontando para o subdomínio de entrada IBM para o cluster. Se o seu domínio for example.com então o CNAME será <myapp>.<example.com> apontando para <myapp>.<ingress-subdomain>.

Com HTTP

  1. Crie uma variável de ambiente que aponte para seu domínio personalizado:
    export CUSTOM_DOMAIN=<example.com>
  2. Crie um arquivo Ingress ingress-customdomain-http.yaml apontando para o seu domínio por meio do arquivo de modelo ingress-customdomain-http-template.yaml:
    ./ingress.sh customdomain_http
  3. Implemente o Ingresso:
    kubectl apply -f ingress-customdomain-http.yaml
  4. Acesse seu aplicativo em http://<myapp>.<example.com>/.

Com HTTPS

Se você estava tentando acessar seu aplicativo com HTTPS nesse momento https://<myapp>.example.com/, provavelmente receberá um aviso de segurança do seu navegador da web dizendo que a conexão não é privada.

Agora, importe seu certificado na instância do Secrets Manager que você configurou anteriormente para seu cluster.

  1. Acesse a instância de serviço Secrets Manager a partir da Lista de Recursos Sob Segurança.

  2. Clique em Segredos na navegação esquerda.

  3. Clique em Incluir.

  4. É possível selecionar Certificado público, Certificado importado ou Certificado privado. As etapas detalhadas estão disponíveis nos respectivos tópicos da documentação: Ordenando certificados públicos SSL/TLS, Importando certificados SSL/TLS ou Criando certificados privados SSL/TLS. Se você selecionou importar um certificado, certifique-se de fazer upload dos arquivos de certificado, chave privada e certificado intermediário.

  5. Localize a entrada para o certificado importado ou solicitado e clique nele.

    • Verifique se o nome do domínio corresponde ao seu $CUSTOM_DOMAIN. Se você transferiu por upload um certificado curinga, um asterisco será incluído no nome de domínio.
    • Clique no ícone de cópia ao lado do CRN do certificado.
    • Crie uma variável de ambiente apontando para o valor que você acabou de copiar:
    export CERTIFICATE_CRN=<certificate CRN>

  6. Crie um segredo do Ingress em seu cluster para o certificado SSL/TLS:

    ibmcloud ks ingress secret create --name nodeapp-tls-cert --cluster $MYCLUSTER --cert-crn $CERTIFICATE_CRN --namespace $KUBERNETES_NAMESPACE

  7. Crie uma variável de ambiente que aponte para seu domínio personalizado:

    export CUSTOM_DOMAIN=<example.com>

  8. Crie um arquivo Ingress ingress-customdomain-https.yaml apontando para seu domínio a partir do modelo ingress-customdomain-https-template-sm.yaml :

    ./ingress.sh customdomain_https_sm

  9. Implemente o Ingresso:

    kubectl apply -f ingress-customdomain-https.yaml

  10. Acesse seu aplicativo em https://$MYAPP.$CUSTOM_DOMAIN/.

curl -I https://$MYAPP.$CUSTOM_DOMAIN

Monitorar o funcionamento do aplicativo

  1. Para verificar o funcionamento de seu aplicativo, navegue para clusters para ver uma lista de clusters e clique em seu cluster.
  2. Clique em Painel do Kubernetes para ativar o painel em uma nova guia.
  3. Clique em Pods à esquerda e, em seguida, clique em um pod-name correspondente a $MYAPP
    • Examine o uso da CPU e da Memória
    • Anote o nome do IP do nó
    • Clique em Visualizar logs no menu de ação no canto superior direito para ver a saída padrão e o erro do aplicativo
  4. Selecione Nodes (Nós ) no painel esquerdo, clique no Nome de um nó mencionado anteriormente e veja os Recursos de alocação para ver a integridade dos seus nós.
  5. Para execução no contêiner, selecione Executar em no menu de ação

Escalar os pods do Kubernetes

À medida que o carregamento aumenta em seu aplicativo, é possível aumentar manualmente o número de réplicas do pod em sua implementação. Réplicas são gerenciadas por um ReplicaSet. Para escalar o aplicativo para duas réplicas, execute o comando a seguir:

kubectl scale deployment kubernetesnodeapp-deployment --replicas=2

Após um breve período, você verá dois pods para seu aplicativo no painel Kubernetes (ou com kubectl get pods ). O controlador Ingress no cluster cuidará do balanceamento de carga entre as duas réplicas.

Com o Kubernetes, é possível ativar o ajuste automático de escala de pod horizontal para aumentar ou diminuir automaticamente o número de instâncias dos apps com base na CPU.

Para criar um ajustador automático de escala e para definir sua política, execute o comando abaixo

kubectl autoscale deployment kubernetesnodeapp-deployment --cpu-percent=5 --min=1 --max=5

Quando o autoscaler for criado com sucesso, você verá horizontalpodautoscaler.autoscaling/<deployment-name> autoscaled.

Remover recursos

  • Exclua o escalador automático de pod horizontal:

    kubectl delete horizontalpodautoscaler.autoscaling/kubernetesnodeapp-deployment

  • Exclua os recursos aplicados:

    kubectl delete -f ingress-customdomain-https.yaml
kubectl delete -f ingress-customdomain-http.yaml
kubectl delete -f ingress-ibmsubdomain.yaml

  • Exclua os artefatos do Kubernetes criados para este aplicativo:

    helm uninstall $MYAPP --namespace $KUBERNETES_NAMESPACE

  • Exclua o segredo do Kubernetes:

    kubectl -n $KUBERNETES_NAMESPACE delete secret kubernetesnodeapp-api-key

  • Excluir o Operador de segredos externos:

    helm uninstall external-secrets

  • Excluir o ID do serviço:

    ibmcloud iam service-id-delete $SERVICE_ID

  • Exclua o cluster.

Conteúdo relacionado