Implantar um app Java do Spring Boot no Kubernetes no Google Kubernetes Engine

1. Antes de começar

O Kubernetes é um projeto de código aberto que pode ser executado em diversos ambientes, de laptops a clusters com vários nós de alta disponibilidade, de nuvens públicas a implantações locais e de instâncias de máquinas virtuais (VMs) a bare metal.

Neste codelab, você vai implantar um app da Web Java simples do Spring Boot no Kubernetes no GKE. O objetivo é executar o app da Web como um app replicado no Kubernetes. Você vai transformar o código desenvolvido na sua máquina em uma imagem de contêiner do Docker e executar essa imagem no GKE.

Você vai usar o GKE, um serviço Kubernetes totalmente gerenciado no Google Cloud, para se concentrar mais na experiência com o Kubernetes, em vez de configurar a infraestrutura subjacente.

Se você quiser executar o Kubernetes no computador, como um laptop de desenvolvimento, conheça o Minikube. Ele oferece uma configuração simples de um cluster do Kubernetes com um único nó para fins de desenvolvimento e teste. Você pode usar o Minikube durante este codelab, se quiser.

O codelab vai usar o exemplo de código do guia sobre Como criar um app com o Spring Boot.

Pré-requisitos

• Noções básicas sobre a linguagem de programação Java e ferramentas
• Conhecimento de editores de texto padrão do Linux, como Vim, Emacs e nano

O que você aprenderá

• Empacotar um app Java simples como um contêiner do Docker.
• Crie seu cluster do Kubernetes no GKE.
• Implante seu app Java no Kubernetes no GKE.
• Escalone verticalmente o serviço e faça um upgrade.
• Acessar o painel do Kubernetes, uma interface de usuário baseada na Web.

O que é necessário

• um projeto do Google Cloud;
• Um navegador, como o Google Chrome

2. Configuração e requisitos

Configuração de ambiente autoguiada

1. Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.

• O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
• O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto.
• Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.

Atenção: o ID do projeto é globalmente exclusivo e não pode ser usado por outras pessoas após a seleção. Você é o único usuário com esse ID. Mesmo que um projeto seja excluído, o ID não poderá ser usado novamente.

Observação: se você usa uma conta do Gmail, defina o local padrão como Sem organização. Se você usa uma conta do Google Workspace, escolha um local adequado para a organização.

2. Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.

Ativar o Cloud Shell

1. No Console do Cloud, clique em Ativar o Cloud Shell.

Se esta for a primeira vez que você inicia o Cloud Shell, uma tela intermediária vai aparecer com a descrição dele. Se isso acontecer, clique em Continuar.

Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.

Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Neste codelab, quase todo o trabalho pode ser feito com um navegador.

Depois de se conectar ao Cloud Shell, você vai ver que sua conta já está autenticada e que o projeto está configurado com o ID do seu projeto.

2. Execute o seguinte comando no Cloud Shell para confirmar se a conta está autenticada:

gcloud auth list

Resposta ao comando

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Observação: a ferramenta de linha de comando gcloud é a poderosa e unificada do Google Cloud. Ela vem pré-instalado no Cloud Shell. Essa ferramenta aceita preenchimento com tabulação. Para mais informações, consulte a visão geral da ferramenta de linha de comando gcloud.

3. Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto:

gcloud config list project

Resposta ao comando

[core]
project = <PROJECT_ID>

Se o projeto não estiver configurado, configure-o usando este comando:

gcloud config set project <PROJECT_ID>

Resposta ao comando

Updated property [core/project].

Observação:se você estiver concluindo este tutorial fora do Cloud Shell, siga as etapas em Configurar as credenciais padrão do aplicativo.

3. Encontrar o código-fonte

Depois que o Cloud Shell for iniciado, use a linha de comando para clonar o código-fonte de exemplo no diretório principal.

$ git clone https://github.com/spring-guides/gs-spring-boot.git
$ cd gs-spring-boot/complete

4. Executar o app localmente

1. Verifique se JAVA_HOME está definido para a versão correta:

$ export JAVA_HOME=/usr/lib/jvm/java-1.17.0-openjdk-amd64

2. Você pode iniciar o app Spring Boot normalmente com o plug-in Spring Boot.

$ ./mvnw -DskipTests spring-boot:run

3. Depois que o app for iniciado, clique em Visualização da Web na barra de ferramentas do Cloud Shell e selecione Visualizar na porta 8080.

Uma guia será aberta no navegador, conectando você ao servidor que acabou de iniciar.

5. Empacotar o app Java como um contêiner do Docker

Em seguida, prepare o app para ser executado no Kubernetes. O primeiro passo é definir o contêiner e o conteúdo dele.

1. Crie o JAR implantável para o app.

$ ./mvnw -DskipTests package

2. Ative a API Artifact Registry para armazenar a imagem do contêiner que você vai criar.

$ gcloud services enable artifactregistry.googleapis.com

3. Crie um novo repositório do Docker se ele não existir. É necessário criar um repositório antes de enviar imagens para ele:

$ gcloud artifacts repositories create codelabrepo     --repository-format=docker --location=us-central1 

4. Sua imagem terá o formato:

{LOCATION}-docker.pkg.dev/{PROJECT-ID}/{REPOSITORY}/{IMAGE-NAME}

Por exemplo, se você criou o repositório no local us-central1 com o nome codelabrepo e quer nomear sua imagem como hello-java:v1, a imagem será:

us-central1-docker.pkg.dev/{PROJECT-ID}/codelabrepo/hello-java:v1

5. Use o Jib para criar a imagem do contêiner e enviá-la por push ao Artifact Registry.

$ export GOOGLE_CLOUD_PROJECT=`gcloud config list --format="value(core.project)"`

$ ./mvnw -DskipTests com.google.cloud.tools:jib-maven-plugin:build -Dimage=us-central1-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/codelabrepo/hello-java:v1

6. Para ver a imagem do contêiner listada no console, acesse a página "Imagens do Artifact Registry" no console do Cloud. Agora você tem uma imagem Docker disponível para todo o projeto, que pode ser acessada e orquestrada pelo Kubernetes, como você verá em alguns minutos.
7. (Opcional) Após a conclusão (levará algum tempo para baixar e extrair tudo), teste a imagem com o comando a seguir, que vai executar um contêiner do Docker como um daemon na porta 8080 na imagem de contêiner que você criou. Se você tiver problemas de permissão, execute gcloud auth configure-docker us-central1-docker.pkg.dev primeiro:

$ docker run -ti --rm -p 8080:8080 \
  us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v1

8. Aproveite o recurso de visualização da Web do Cloud Shell.

9. A página padrão vai aparecer em uma nova guia. Depois de verificar que o app está sendo executado localmente em um contêiner do Docker, você pode parar o contêiner em execução pressionando Control+C.

6. Crie o cluster

Agora você está pronto para criar seu cluster do GKE. Um cluster consiste em um servidor de API do Kubernetes gerenciado pelo Google e um conjunto de nós de trabalho. Os nós de trabalho são VMs do Compute Engine.

1. Primeiro, verifique se os recursos relacionados da API estão ativados.

$ gcloud services enable compute.googleapis.com container.googleapis.com

2. Crie um cluster com dois nós n1-standard-1. Esse processo vai levar alguns minutos.

$ gcloud container clusters create hello-java-cluster \
  --num-nodes 2 \
  --machine-type n1-standard-1 \
  --zone us-central1-c

No final, você verá o cluster criado.

Creating cluster hello-java-cluster...done.
Created [https://container.googleapis.com/v1/projects/...].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-java-cluster  us-central1-c  ...

Observação:como alternativa, você pode criar o cluster no console do Cloud. Para acessar, clique em Menu de navegação > Kubernetes Engine > Clusters > Criar cluster. Você pode criar um cluster em outra zona, mas é recomendável permanecer na mesma região que o bucket de armazenamento usado pelo Container Registry.

Agora você tem um cluster do Kubernetes totalmente funcional com a tecnologia do GKE.

Agora é hora de implantar o app em contêiner no cluster do Kubernetes. A partir de agora, use a linha de comando kubectl (já configurada no seu ambiente shell do Cloud Shell). O restante do codelab exige que a versão do cliente e do servidor do Kubernetes seja 1.2 ou mais recente. O comando kubectl version mostra a versão atual.

7. Implantar o app no Kubernetes

1. Uma implantação do Kubernetes pode criar, gerenciar e escalonar várias instâncias do seu app usando a imagem de contêiner criada. Implante uma instância do app no Kubernetes usando o comando kubectl run.

$ kubectl create deployment hello-java --image=us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v1

2. Para conferir a implantação que você criou, execute o seguinte comando:

$ kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   1         1         1            1           37s

3. Para ver as instâncias de app criadas pela implantação, execute o seguinte comando:

$ kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-java-714049816-ztzrb   1/1       Running   0          57s

Neste ponto, você tem o contêiner em exibição sob o controle do Kubernetes, mas ainda precisa torná-lo acessível ao mundo exterior.

8. permitir o tráfego externo

Por padrão, o pod é acessível somente do IP interno dele dentro do cluster. Para tornar o contêiner hello-java acessível de fora da rede virtual do Kubernetes, é necessário expor o pod como um serviço do Kubernetes.

1. No Cloud Shell, é possível expor o pod à Internet pública criando um serviço LoadBalancer do Kubernetes.

$ kubectl create service loadbalancer hello-java --tcp=8080:8080

Você expôs a implantação, não o pod diretamente. Isso fará com que o serviço resultante faça o balanceamento de carga do tráfego em todos os pods gerenciados pela implantação (nesse caso, apenas um pod, mas você adicionará mais réplicas depois).

O mestre do Kubernetes cria o balanceador de carga e as regras de encaminhamento do Compute Engine relacionadas, os pools de destino e as regras de firewall para tornar o serviço totalmente acessível de fora do Google Cloud.

2. Para encontrar o endereço IP publicamente acessível do serviço, basta solicitar que o kubectl liste todos os serviços de cluster.

$ kubectl get services

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-java   10.3.253.62    aaa.bbb.ccc.ddd  8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

Observação:o EXTERNAL-IP pode levar vários minutos para ficar disponível e visível. Se o EXTERNAL-IP estiver ausente, aguarde alguns minutos e tente de novo.

3. Agora, você conseguirá acessar o serviço com este endereço no navegador: http://<EXTERNAL_IP>:8080.

9. Escalonar seu serviço

Um dos recursos poderosos oferecidos pelo Kubernetes é a facilidade de escalonar seu app. Suponha que você precise de mais capacidade para seu app. Basta dizer ao controlador de replicação para gerenciar um novo número de réplicas das instâncias do app.

$ kubectl scale deployment hello-java --replicas=3

deployment "hello-java" scaled

$ kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   3         3         3            3           22m

Observe a abordagem declarativa. Em vez de iniciar ou interromper novas instâncias, você declara quantas instâncias precisam estar em execução o tempo todo. Os loops de reconciliação do Kubernetes garantem que a realidade corresponda ao que você solicitou e entram em ação, se necessário.

10. implementar uma atualização no serviço

Em algum momento, o app implantado na produção vai precisar de correções de bugs ou recursos adicionais. O Kubernetes ajuda você a implantar uma nova versão na produção sem afetar os usuários.

1. Clique em Abrir editor no menu do Cloud Shell para abrir o editor de código.
2. Navegue até src/main/java/com/example/springboot/HelloController.java e atualize o valor da resposta.

package com.example.springboot;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class HelloController {

    @RequestMapping("/")
    public String index() {
        return "Greetings from Google Kubernetes Engine!";
    }
}

3. Use o Jib para criar e enviar uma nova versão da imagem do contêiner. O processo de criação e envio da imagem atualizada será muito mais rápido com o benefício do armazenamento em cache.

$ ./mvnw -DskipTests package com.google.cloud.tools:jib-maven-plugin:build -Dimage=us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v2

Agora já está tudo pronto para o Kubernetes atualizar o controlador de replicação para a nova versão do app.

4. Para mudar o rótulo da imagem do contêiner em execução, edite a implantação hello-java e mude a imagem de us-central1-docker.pkg.dev/PROJECT_ID/codelabrepo/hello-java:v1

para us-central1-docker.pkg.dev/PROJECT_ID/codelabrepo/hello-java:v2

5. Use o comando kubectl set image para pedir ao Kubernetes que implante a nova versão do app em todo o cluster, uma instância por vez, com atualizações contínuas.

$ kubectl set image deployment/hello-java hello-java=us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v2

deployment "hello-java" image updated

Observação:enquanto isso acontece, os usuários dos serviços podem sofrer interrupções, mas isso ocorre porque não há uma verificação de integridade configurada. Essa é uma configuração um pouco mais avançada que está além do escopo do codelab.

6. Verifique http://EXTERNAL_IP:8080 novamente para ver se ele está retornando a nova resposta.

11. Reverter

Ops! Você cometeu um erro com uma nova versão do app? Talvez a nova versão tenha um erro e você precise reverter rapidamente. Com o Kubernetes, é fácil reverter para o estado anterior. Reverta o app executando o seguinte comando:

$ kubectl rollout undo deployment/hello-java

A resposta antiga vai aparecer quando você marcar http://EXTERNAL_IP:8080 de novo.

12. Parabéns

Você aprendeu a criar e implantar um novo app da Web baseado em Java no Kubernetes no GKE.

Limpeza

$ gcloud container clusters delete hello-java-cluster --zone us-central1-c

$ gcloud container images delete us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v1 us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v2

Saiba mais

• Java no Google Cloud
• Exemplos de código Java
• Kubernetes no GKE: do básico ao avançado