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

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 código de exemplo 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.
• Acesse 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

Configuração de ambiente autoguiada

1. Faça login no console do Cloud e crie um novo projeto ou reutilize um existente. Crie uma se você ainda não tiver uma conta do Gmail ou do G Suite.

Observação: para acessar facilmente o console do Cloud, basta memorizar o URL, que é console.cloud.google.com.

Lembre-se do código do projeto, um nome exclusivo em todos os projetos do Google Cloud. O nome acima já foi escolhido e não servirá para você. Faremos referência a ele mais adiante neste codelab como PROJECT_ID.

Observação: se você estiver usando uma conta do Gmail, deixe o local padrão definido como Sem organização. Se você estiver usando uma conta do G Suite, escolha um local adequado à sua organização.

2. Em seguida, será necessário ativar o faturamento no console do Cloud para usar os recursos do Google Cloud.

A execução deste codelab não deve custar mais do que alguns dólares, mas pode ser mais se você decidir usar mais recursos ou deixá-los em execução.

Novos usuários do Google Cloud estão qualificados para um teste sem custo financeiro de US$300.

Ativar o Cloud Shell

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

Se você nunca tiver iniciado o Cloud Shell, verá uma tela intermediária (abaixo da dobra) com a descrição do que ele é. Se esse for o caso, clique em Continuar e você não o verá novamente. Esta é a aparência dessa tela única:

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. Praticamente todo o seu trabalho neste codelab pode ser feito em um navegador ou no seu Chromebook.

Depois de se conectar ao Cloud Shell, você já estará autenticado e o projeto já estará configurado com seu ID do projeto.

2. Execute o seguinte comando no Cloud Shell para confirmar que você está autenticado:

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.

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].

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

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

$ ./mvnw -DskipTests spring-boot:run

2. 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.

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 arquivo JAR implantável para o app.

$ ./mvnw -DskipTests package

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

$ gcloud services enable containerregistry.googleapis.com

3. Use o Jib para criar a imagem do contêiner e enviá-la ao Container Registry.

$ ./mvnw -DskipTests com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

4. Se tudo der certo, você vai ver a imagem do contêiner listada no console. Para isso, acesse Container Registry > Imagens. Agora você tem uma imagem do Docker disponível para todo o projeto, que pode ser acessada e orquestrada pelo Kubernetes, como você verá em alguns minutos.

Observação:embora você tenha usado um domínio genérico para o registro (gcr.io), também é possível ser mais específico sobre qual zona e bucket usar. Para mais informações, consulte a documentação do Container Registry.

5. Depois que isso for concluído (vai levar algum tempo para baixar e extrair tudo), você poderá testar a imagem localmente 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:

$ docker run -ti --rm -p 8080:8080 \
  gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

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

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

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
Operation "operations/..." finished successfully

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 o GKE.

Agora é hora de implantar o app em contêiner no cluster do Kubernetes. A partir de agora, use a linha de comando kubectl, que já foi configurada no ambiente 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 kubectl version vai mostrar a versão atual do comando.

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

$ kubectl create deployment hello-java \
  --image=gcr.io/$GOOGLE_CLOUD_PROJECT/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 comando a seguir:

$ 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.

Por padrão, o pod é acessível somente do seu IP interno 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 com o comando kubectl expose combinado com a flag --type=LoadBalancer. A flag é obrigatória para a criação de um IP acessível externamente.

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

A flag usada no comando especifica que você vai usar o balanceador de carga fornecido pela infraestrutura subjacente. 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 posteriormente).

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 pedir 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. Há dois endereços IP listados para o serviço, ambos usando a porta 8080. Um é o endereço IP interno que é visível apenas dentro da sua nuvem privada virtual. O outro é o endereço IP externo balanceado por carga. No exemplo, o endereço IP externo é aaa.bbb.ccc.ddd. Agora, você deve conseguir acessar o serviço com este endereço no navegador: http://<EXTERNAL_IP>:8080.

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.

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 Iniciar editor no menu do Cloud Shell para abrir o editor de código.
2. Navegue até src/main/java/hello/HelloController.java e atualize o valor da resposta.

package hello;

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.

$ ./mvnw -DskipTests package \
  com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

Observação : o processo de criação e envio da imagem atualizada será muito mais rápido com o benefício do armazenamento em cache.

Agora 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 gcr.io/PROJECT_ID/hello-java:v1 para gcr.io/PROJECT_ID/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=gcr.io/$GOOGLE_CLOUD_PROJECT/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 conferir se ele está retornando a nova resposta.

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

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

Saiba mais

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