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

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

Sobre este codelab

Último abr. 22, 2020 atualizado

Escrito por um Googler

1. Antes de começar

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

Neste codelab, você implantará um app da Web Java do Spring Boot simples no Kubernetes no GKE, com o objetivo de executar o app da Web como um aplicativo replicado no Kubernetes. Você transformará uma imagem de contêiner do Docker em uma imagem de contêiner do Docker e executará a imagem no GKE.

Você usará o GKE, um serviço do Kubernetes totalmente gerenciado no Google Cloud, para se concentrar mais na experiência do Kubernetes e não na infraestrutura subjacente.

Se você tiver interesse em executar o Kubernetes na sua máquina local, como um laptop de desenvolvimento, veja o Minikube. Ele oferece uma configuração simples de um cluster do Kubernetes de nó único para fins de desenvolvimento e teste. Se quiser, use o Minikube para realizar o codelab.

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

Pré-requisitos

• Familiaridade com uma linguagem de programação Java e ferramentas
• Conhecimento sobre os 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.
• Expanda seu serviço e lance um upgrade.
• Acessar o painel, uma interface do usuário do Kubernetes 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 personalizada

1. Faça login no Console do Cloud e crie um novo projeto ou reutilize um existente. Se você ainda não tem uma conta do Gmail ou do G Suite, crie uma.

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, você precisará ativar o faturamento no Console do Cloud para usar os recursos do Google Cloud.

A execução por este codelab não deve custar mais do que alguns dólares, mas pode ser mais se você decidir usar mais recursos ou se 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 é uma 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 ferramenta de linha de comando avançada e unificada no 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, faça a configuração usando este comando:

gcloud config set project <PROJECT_ID>

Resposta ao comando

Updated property [core/project].

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. Você pode iniciar o app Spring Boot normalmente com o plug-in.

$ ./mvnw -DskipTests spring-boot:run

2. Depois que o aplicativo for iniciado, clique em Visualização na 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, você precisa preparar seu aplicativo para ser executado no Kubernetes. O primeiro passo é definir o contêiner e o conteúdo dele.

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

$ ./mvnw -DskipTests package

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

$ gcloud services enable containerregistry.googleapis.com

3. Use o Jib para criar a imagem do contêiner e enviá-la para o 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ê poderá ver a imagem do contêiner listada no console navegando até Container Registry > Imagens. Agora você tem uma imagem do Docker disponível para todo o projeto. O Kubernetes pode acessá-la e orquestrar, 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 (ele levará algum tempo para fazer o download e extrair tudo), teste a imagem localmente com o seguinte comando, que executará um contêiner do Docker como um daemon na porta 8080 a partir da sua imagem de contêiner recém-criada:

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

6. Mais uma vez, use o recurso de visualização da Web do Cloud Shell.

7. Você verá a página padrão em uma nova guia. Depois de verificar se o app está sendo executado localmente em um contêiner do Docker, interrompa o contêiner em execução pressionando Control+C.

6. Crie o cluster

Está tudo pronto para você 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 da API relacionados 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 (ele levará alguns minutos para ser concluído).

$ 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, é possível criar o cluster no Console do Cloud. Para acessá-lo, clique em Menu de navegação > Kubernetes Engine > Clusters > Criar cluster. É possível 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ê deve ter um cluster completo do Kubernetes com a tecnologia do GKE.

Agora é hora de implantar o aplicativo conteinerizado no cluster do Kubernetes. A partir de agora, você usará a linha de comando kubectl, que já está configurada no seu ambiente do Cloud Shell. O restante do codelab requer a versão 1.2 ou superior do cliente e do servidor do Kubernetes. kubectl version mostrará a versão atual do comando.

7. Implantar seu app no Kubernetes

1. Uma implantação do Kubernetes pode criar, gerenciar e escalonar várias instâncias do app usando a imagem de 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 ver a implantação criada, basta executar 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 do 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

O contêiner deve estar em execução sob o controle do Kubernetes, mas ainda é preciso torná-lo acessível ao mundo exterior.

8. Permita o tráfego externo

Por padrão, o pod só é acessível pelo IP interno no 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 sinalização --type=LoadBalancer. A sinalização é necessária para a criação de um IP acessível externamente.

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

A sinalização usada no comando especifica que você usará o balanceador de carga fornecido pela infraestrutura subjacente. Você expõe diretamente a implantação, não o pod. 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, os pools de destino e as regras de firewall do Compute Engine 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 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 novamente.

3. Há dois endereços IP listados para seu serviço, ambos exibindo a porta 8080. Um é o endereço IP interno visível apenas na sua nuvem privada virtual. O outro é o endereço IP externo com balanceamento de carga. No exemplo, o endereço IP externo é aaa.bbb.ccc.ddd. Agora, você deve conseguir acessar o serviço, apontando o navegador para http://<EXTERNAL_IP>:8080.

9. Escalone o serviço

Um dos recursos avançados oferecidos pelo Kubernetes é a facilidade de escalonar o app. Suponha que, de repente, você precise de mais capacidade para o app. Você pode simplesmente dizer ao controlador de replicação para gerenciar um novo número de réplicas para suas instâncias de apps.

$ 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 apenas garantem que a realidade corresponda ao que você solicitou e realiza ações, se necessário.

10. Implemente uma atualização no seu serviço

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

1. Para abrir o editor de código, clique em Launch editor no menu do Cloud Shell.
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: a criação e o envio da imagem atualizada serão muito mais rápidos quando você aproveitar ao máximo o armazenamento em cache.

Está tudo pronto para que o Kubernetes atualize seu 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 atual de hello-java e altere 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 solicitar que o Kubernetes implante a nova versão do app em todo o cluster, uma instância de cada vez, com atualizações graduais.

$ 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 não acontece 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 contenha um erro e você precise revertê-la rapidamente. Com o Kubernetes, é possível reverter facilmente ao estado anterior. Reverta o app executando o seguinte comando:

$ kubectl rollout undo deployment/hello-java

12. Parabéns

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

Saiba mais

• Java no Google Cloud
• Amostras de código Java
• Kubernetes no GKE: conceitos básicos para avançados