Implemente uma app Web contentorizada do Docker no GKE

Este tutorial mostra como implementar uma aplicação Web contentorizada num cluster do Google Kubernetes Engine (GKE).

Esta página destina-se a operadores e programadores que preparam e configuram recursos na nuvem, e implementam apps e serviços. Para saber mais sobre as funções comuns e as tarefas de exemplo referenciadas no Google Cloud conteúdo, consulte o artigoFunções e tarefas comuns do utilizador do GKE.

Antes de ler esta página, certifique-se de que conhece o Kubernetes.

Objetivos

  • Empacote uma aplicação Web de amostra numa imagem do Docker.
  • Carregue a imagem do Docker para o Artifact Registry.
  • Crie um cluster do GKE.
  • Implemente a app de exemplo no cluster.
  • Faça a gestão do dimensionamento automático para a implementação.
  • Exponha a app de exemplo à Internet.
  • Implemente uma nova versão da app de exemplo.

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.

Antes de começar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  8. Ativar Cloud Shell

    A Cloud Shell vem pré-instalada com as ferramentas de linha de comandos gcloud, docker e kubectl que são usadas neste tutorial.

    1. Aceda à Google Cloud consola.
    2. Clique no botão Ativar Cloud Shell Ativar botão Shell na parte superior da janela da Google Cloud consola.

      É aberta uma sessão do Cloud Shell num novo frame na parte inferior da Google Cloud consola e é apresentado um comando.

      Sessão do Cloud Shell

    Crie um repositório

    Neste tutorial, armazena uma imagem no Artifact Registry e implementa-a a partir do registo. Para este início rápido, vai criar um repositório com o nome hello-repo.

    1. Defina a variável de ambiente PROJECT_ID para o Google Cloud ID do projeto (PROJECT_ID). Vai usar esta variável de ambiente quando criar a imagem do contentor e a enviar para o seu repositório.

      export PROJECT_ID=PROJECT_ID
      
    2. Confirme que a variável de ambiente PROJECT_ID tem o valor correto:

      echo $PROJECT_ID
      
    3. Defina o ID do projeto para a CLI Google Cloud:

      gcloud config set project $PROJECT_ID
      

      Saída:

      Updated property [core/project].
      
    4. Crie o repositório hello-repo com o seguinte comando:

      gcloud artifacts repositories create hello-repo \
         --repository-format=docker \
         --location=REGION \
         --description="Docker repository"
      

      Substitua REGION por uma região para o repositório, como us-west1. Para ver uma lista de localizações disponíveis, execute o comando:

       gcloud artifacts locations list
      

    Crie a imagem do hello-app Docker

    Neste tutorial, implementa uma aplicação Web de exemplo denominada hello-app, um servidor Web escrito em Go que responde a todos os pedidos com a mensagem Hello, World! na porta 8080.

    O GKE aceita imagens Docker como o formato de implementação de aplicações. Antes de implementar o hello-app no GKE, tem de criar um pacote do código fonte do hello-app como uma imagem do Docker.

    Para criar uma imagem do Docker, precisa de código-fonte e de um Dockerfile. Um Dockerfile contém instruções sobre como a imagem é criada.

    1. Transfira o hello-app código-fonte e o Dockerfile executando os seguintes comandos:

      git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
      cd kubernetes-engine-samples/quickstarts/hello-app
      
    2. Crie e etiquete a imagem de Docker para hello-app:

      docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 .
      

      Este comando indica ao Docker para criar a imagem usando o Dockerfile no diretório atual, guardá-la no seu ambiente local e etiquetá-la com um nome, como us-west1-docker.pkg.dev/my-project/hello-repo/hello-app:v1. A imagem é enviada para o Artifact Registry na secção seguinte.

      • A variável PROJECT_ID associa a imagem do contentor ao hello-reporepositório no seu Google Cloud projeto.
      • O prefixo us-west1-docker.pkg.dev refere-se ao Artifact Registry, anfitrião regional do seu repositório.
    3. Execute o comando docker images para verificar se a compilação foi bem-sucedida:

      docker images
      

      Saída:

      REPOSITORY                                                 TAG     IMAGE ID       CREATED          SIZE
      us-west1-docker.pkg.dev/my-project/hello-repo/hello-app    v1      25cfadb1bf28   10 seconds ago   54 MB
      
    4. Adicione associações de políticas IAM à sua conta de serviço:

      gcloud artifacts repositories add-iam-policy-binding hello-repo \
          --location=REGION \
          --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
          --role="roles/artifactregistry.reader"
      

      Substitua PROJECT_NUMBER pelo número do projeto do seu projeto.

    (Opcional) Execute o contentor Docker localmente

    1. Teste a imagem do contentor com o motor Docker local:

      docker run --rm -p 8080:8080 REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
      
    2. Clique no botão Pré-visualização na Web Botão de pré-visualização da Web e, de seguida, selecione o número da porta 8080. O GKE abre o URL de pré-visualização no respetivo serviço de proxy numa nova janela do navegador.

    Envie a sua imagem de Docker para o Artifact Registry

    Tem de carregar a imagem do contentor para um registo para que o cluster do GKE possa transferir e executar a imagem do contentor. Neste tutorial, vai armazenar o seu contentor no Artifact Registry.

    1. Configure a ferramenta de linha de comandos do Docker para autenticar no Artifact Registry:

      gcloud auth configure-docker REGION-docker.pkg.dev
      
    2. Envie a imagem do Docker que acabou de criar para o repositório:

      docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
      

    Crie um cluster do GKE

    Agora que a imagem do Docker está armazenada no Artifact Registry, crie um cluster do GKE para executar o hello-app. Um cluster do GKE consiste num conjunto de instâncias de VM do Compute Engine que executam o Kubernetes, o sistema de orquestração de clusters de código aberto que alimenta o GKE.

    Cloud Shell

    1. Defina a região do Compute Engine:

       gcloud config set compute/region REGION
      

      Para clusters zonais padrão, defina uma zona do Compute Engine mais próxima do repositório do Artifact Registry.

    2. Crie um cluster com o nome hello-cluster:

       gcloud container clusters create-auto hello-cluster
      

      Demora alguns minutos para que o cluster do GKE seja criado e a respetiva integridade seja verificada. Para executar este tutorial num cluster padrão do GKE, use o comando gcloud container clusters create.

    Consola

    1. Na Google Cloud consola, aceda à página Criar um cluster do Autopilot.

      Aceda a Crie um cluster do Autopilot

    2. No campo Nome, introduza o nome hello-cluster.

    3. Selecione uma região do Compute Engine na lista pendente Região, como us-west1.

    4. Clique em Criar.

    5. Aguarde a criação do cluster. Quando o cluster estiver pronto, é apresentada uma marca de verificação junto ao nome do cluster.

    Implemente o hello-app no GKE

    Já tem tudo pronto para implementar a imagem do Docker que criou no seu cluster do GKE.

    O Kubernetes representa as aplicações como Pods, que são unidades escaláveis que contêm um ou mais contentores. O Pod é a unidade implementável mais pequena no Kubernetes. Normalmente, implementa os pods como um conjunto de réplicas que podem ser dimensionadas e distribuídas em conjunto no seu cluster. Uma forma de implementar um conjunto de réplicas é através de uma implementação do Kubernetes.

    Nesta secção, cria uma implementação do Kubernetes para executar o hello-app no seu cluster. Esta implementação tem réplicas (pods). Um pod de implementação contém apenas um contentor: a imagem do hello-app Docker. Também cria um recurso HorizontalPodAutoscaler que dimensiona o número de pods de 3 para um número entre 1 e 5, com base na carga da CPU.

    Cloud Shell

    1. Certifique-se de que tem ligação ao cluster do GKE.

      gcloud container clusters get-credentials hello-cluster
      
    2. Crie uma implementação do Kubernetes para a sua hello-app imagem do Docker.

      kubectl create deployment hello-app --image=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
      
    3. Defina o número de réplicas de implementação de base como 3.

      kubectl scale deployment hello-app --replicas=3
      
    4. Crie um recurso HorizontalPodAutoscaler para a sua implementação.

      kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=5
      
    5. Para ver os pods criados, execute o seguinte comando:

      kubectl get pods
      

      Saída:

      NAME                         READY   STATUS    RESTARTS   AGE
      hello-app-784d7569bc-hgmpx   1/1     Running   0          90s
      hello-app-784d7569bc-jfkz5   1/1     Running   0          90s
      hello-app-784d7569bc-mnrrl   1/1     Running   0          95s
      

    Consola

    1. Aceda à página Workloads na Google Cloud consola.

      Visitar cargas de trabalho

    2. Clique em Implementar.

    3. Na secção Especificar contentor, selecione Imagem de contentor existente.

    4. No campo Caminho da imagem, clique em Selecionar.

    5. No painel Selecionar imagem do contentor, selecione a imagem hello-app que enviou para o Artifact Registry e clique em Selecionar.

    6. Na secção Contentor, clique em Concluído e, de seguida, em Continuar.

    7. Na secção Configuração, em Etiquetas, introduza app para Chave e hello-app para Valor.

    8. Em YAML de configuração, clique em Ver YAML. Esta ação abre um ficheiro de configuração YAML que representa os dois recursos da API Kubernetes prestes a serem implementados no seu cluster: uma implementação e um HorizontalPodAutoscaler para essa implementação.

    9. Clique em Fechar e, de seguida, em Implementar.

    10. Quando os pods de implementação estiverem prontos, é apresentada a página Detalhes da implementação.

    11. Em Managed pods (Pods geridos), repare nos três pods em execução para a hello-app implementação.

    Exponha a app à Internet

    Embora os pods tenham endereços IP atribuídos individualmente, só é possível aceder a esses IPs a partir do interior do cluster. Além disso, os pods do GKE são concebidos para serem temporários, iniciando ou parando com base nas necessidades de escalabilidade. Além disso, quando um pod falha devido a um erro, o GKE volta a implementar automaticamente esse pod, atribuindo um novo endereço IP do pod de cada vez.

    Isto significa que, para qualquer implementação, o conjunto de endereços IP correspondente ao conjunto ativo de pods é dinâmico. Precisamos de uma forma de 1) agrupar os pods num nome de anfitrião estático e 2) expor um grupo de pods fora do cluster à Internet.

    Os serviços do Kubernetes resolvem ambos os problemas. Os serviços agrupam os pods num endereço IP estático, acessível a partir de qualquer pod no cluster. O GKE também atribui um nome de anfitrião DNS a esse IP estático. Por exemplo, hello-app.default.svc.cluster.local.

    O tipo de serviço predefinido no GKE chama-se ClusterIP, em que o serviço recebe um endereço IP acessível apenas a partir do interior do cluster. Para expor um serviço do Kubernetes fora do cluster, crie um serviço do tipo LoadBalancer. Este tipo de serviço gera um IP do balanceador de carga externo para um conjunto de pods, acessível através da Internet.

    Nesta secção, expõe a hello-app implementação à Internet através de um serviço do tipo LoadBalancer.

    Cloud Shell

    1. Use o comando kubectl expose para gerar um serviço Kubernetes para a implementação hello-app:

      kubectl expose deployment hello-app --name=hello-app-service --type=LoadBalancer --port 80 --target-port 8080
      

      Aqui, a flag --port especifica o número da porta configurado no equilibrador de carga e a flag --target-port especifica o número da porta em que o contentor hello-app está a escutar.

    2. Execute o seguinte comando para obter os detalhes do serviço para hello-app-service:

      kubectl get service
      

      Saída:

      NAME                 CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
      hello-app-service    10.3.251.122    203.0.113.0     80:30877/TCP     10s
      
    3. Copie o endereço EXTERNAL_IP para a área de transferência (por exemplo: 203.0.113.0).

    Consola

    1. Aceda à página Workloads na Google Cloud consola.

      Aceda a Cargas de trabalho

    2. Clique em hello-app.

    3. Na página Deployment details (Detalhes da implementação), clique em Actions > Expose (Ações > Expor).

    4. Na caixa de diálogo Expor, defina a Porta de destino como 8080. Esta é a porta que o contentor hello-app escuta.

    5. Na lista pendente Tipo de serviço, selecione Equilibrador de carga.

    6. Clique em Expor para criar um serviço Kubernetes para hello-app.

    7. Quando o balanceador de carga estiver pronto, é apresentada a página Detalhes do serviço.

    8. Desloque a página para baixo até ao campo Pontos finais externos e copie o endereço IP.

    Agora que os hello-apppods estão expostos à Internet através de um serviço Kubernetes, pode abrir um novo separador do navegador e navegar para o endereço IP do serviço que copiou para a área de transferência. É apresentada uma mensagem Hello, World!, juntamente com um campo Hostname. O Hostname corresponde a um dos três hello-app pods que publicam o seu pedido HTTP no seu navegador.

    Implemente uma nova versão do hello-app

    Nesta secção, atualiza o hello-app para uma nova versão criando e implementando uma nova imagem do Docker no seu cluster do GKE.

    A atualização contínua do Kubernetes permite-lhe atualizar as suas implementações sem períodos de inatividade. Durante uma atualização contínua, o cluster do GKE substitui incrementalmente os hello-apppods existentes por pods que contêm a imagem do Docker para a nova versão. Durante a atualização, o serviço de balanceamento de carga encaminha o tráfego apenas para os pods disponíveis.

    1. Regresse ao Cloud Shell, onde clonou o código fonte da app hello e o Dockerfile. Atualize a função hello() no ficheiro main.go para comunicar a nova versão 2.0.0.

    2. Crie e etiquete uma nova imagem do hello-app Docker.

      docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 .
      
    3. Envie a imagem para o Artifact Registry.

      docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2
      

    Agora, já pode atualizar a sua implementação do hello-app Kubernetes para usar uma nova imagem do Docker.

    Cloud Shell

    1. Aplique uma atualização contínua à hello-app implementação existente com uma atualização de imagem através do comando kubectl set image:

      kubectl set image deployment/hello-app hello-app=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2
      
    2. Veja os pods em execução com a imagem v1 parar e os novos pods em execução com a imagem v2 iniciar.

      watch kubectl get pods
      

      Saída:

      NAME                        READY   STATUS    RESTARTS   AGE
      hello-app-89dc45f48-5bzqp   1/1     Running   0          2m42s
      hello-app-89dc45f48-scm66   1/1     Running   0          2m40s
      
    3. Num separador separado, navegue novamente para o hello-app-service IP externo. Agora, deve ver o Version definido como 2.0.0.

    Consola

    1. Aceda à página Workloads na Google Cloud consola.

      Aceda a Cargas de trabalho

    2. Clique em hello-app.

    3. Na página Detalhes da implementação, clique em Ações > Atualização contínua.

    4. Na caixa de diálogo Atualização contínua, defina o campo Imagem de hello-app como REGION-docker.pkg.dev/PROJECT_ID/hello-repo/hello-app:v2.

    5. Clique em Atualizar.

    6. Na página Detalhes da implementação, inspecione a secção Revisões ativas. Agora, deve ver duas revisões, 1 e 2. A revisão 1 corresponde à implementação inicial que criou anteriormente. A revisão 2 é a atualização incremental que acabou de iniciar.

    7. Após alguns momentos, atualize a página. Em Pods geridos, todas as réplicas de hello-app correspondem agora à revisão 2.

    8. Num separador separado, navegue novamente para o endereço IP do serviço que copiou. O Version deve ser 2.0.0.

    Limpar

    Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.

    1. Eliminar o serviço: esta ação anula a atribuição do Cloud Load Balancer criado para o seu serviço:

      kubectl delete service hello-app-service
      
    2. Elimine o cluster: esta ação elimina os recursos que compõem o cluster, como as instâncias de cálculo, os discos e os recursos de rede:

      gcloud container clusters delete hello-cluster
      
    3. Elimine as suas imagens de contentores: esta ação elimina as imagens Docker que enviou para o Artifact Registry.

      gcloud artifacts docker images delete \
          REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 \
          --delete-tags --quiet
      gcloud artifacts docker images delete \
          REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 \
          --delete-tags --quiet
      

    O que se segue?

    Experimente

    Se está a usar o Google Cloud pela primeira vez, crie uma conta para avaliar o desempenho do GKE em cenários reais. Os novos clientes também recebem 300 USD em créditos gratuitos para executar, testar e implementar cargas de trabalho.

    Experimente o GKE gratuitamente