Desenvolvimento de InnerLoop com Java - SpringBoot

1. Visão geral

Este laboratório demonstra recursos e funcionalidades projetados para simplificar o fluxo de trabalho de desenvolvimento de engenheiros de software responsáveis por desenvolver aplicativos Java em um ambiente conteinerizado. O desenvolvimento típico de contêineres exige que o usuário entenda os detalhes dos contêineres e do processo de build deles. Além disso, os desenvolvedores geralmente precisam interromper o fluxo de trabalho, saindo do ambiente de desenvolvimento integrado para testar e depurar os aplicativos em ambientes remotos. Com as ferramentas e tecnologias mencionadas neste tutorial, os desenvolvedores podem trabalhar de forma eficaz com aplicativos contêinerizados sem sair do ambiente de desenvolvimento integrado.

O que você vai aprender

Neste laboratório, você vai aprender métodos para desenvolver com contêineres no GCP, incluindo:

• Configuração e requisitos
• Como criar um novo aplicativo inicial em Java
• Como percorrer o processo de desenvolvimento
• Como desenvolver um serviço REST CRUD simples
• Limpeza

2. Configuração e requisitos

Configuração de ambiente personalizada

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. Ele é uma string de caracteres que não é usada pelas APIs do Google e pode ser atualizada a qualquer momento.
• O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser alterado após a definição. O Console do Cloud gera automaticamente uma string única, geralmente não importa o que seja. Na maioria dos codelabs, você precisará fazer referência ao ID do projeto, que geralmente é identificado como PROJECT_ID. Então, se você não gostar dele, gere outro ID aleatório ou crie um próprio e veja se ele está disponível. Em seguida, ele fica "congelado" depois que o projeto é criado.
• Há um terceiro valor, um Número de projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.

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

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 Google Workspace, escolha um local adequado à sua organização.

2. Em seguida, você precisará ativar o faturamento no Console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não será muito cara, se tiver algum custo. Para encerrar os recursos e não gerar cobranças além deste tutorial, siga as instruções de "limpeza" encontradas no final do codelab. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.

Iniciar o editor do Cloud Shell

Este laboratório foi projetado e testado para uso com o editor do Google Cloud Shell. Para acessar o editor,

1. Acesse seu projeto do Google em https://console.cloud.google.com.
2. No canto superior direito, clique no ícone do editor do Cloud Shell.

3. Um novo painel será aberto na parte de baixo da janela
4. Clique no botão "Abrir editor".

5. O editor será aberto com um explorador à direita e o editor na área central.
6. Um painel de terminal também vai estar disponível na parte de baixo da tela.
7. Se o terminal NÃO estiver aberto, use a combinação de teclas "ctrl+`" para abrir uma nova janela do terminal.

Configurar a gcloud

No Cloud Shell, defina o ID do projeto e a região em que você quer implantar o aplicativo. Salve-as como variáveis PROJECT_ID e REGION.

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')

Conseguir o código-fonte

O código-fonte deste laboratório está localizado no container-developer-workshop em GoogleCloudPlatform no GitHub. Clone com o comando abaixo e mude para o diretório.

git clone https://github.com/GoogleCloudPlatform/container-developer-workshop.git
cd container-developer-workshop/labs/spring-boot

Provisionar a infraestrutura usada neste laboratório

Neste laboratório, você vai implantar código no GKE e acessar dados armazenados em um banco de dados do Cloud SQL. O script de configuração abaixo prepara essa infraestrutura para você. O processo de provisionamento vai levar mais de 10 minutos. Você pode continuar com as próximas etapas enquanto a configuração é processada.

./setup.sh

3. Como criar um novo aplicativo inicial em Java

Nesta seção, você vai criar um novo aplicativo Java Spring Boot do zero usando um aplicativo de exemplo fornecido por spring.io.

Clonar o aplicativo de exemplo

1. Criar um aplicativo inicial

curl  https://start.spring.io/starter.zip -d dependencies=web -d type=maven-project -d javaVersion=11 -d packageName=com.example.springboot -o sample-app.zip

2. Descompacte o aplicativo

unzip sample-app.zip -d sample-app

3. Mude para o diretório sample-app e abra a pasta no espaço de trabalho do Cloud Shell IDE.

cd sample-app && cloudshell workspace .

Adicionar spring-boot-devtools e Jib

Para ativar o Spring Boot DevTools, encontre e abra o pom.xml no explorador do editor. Em seguida, cole o código a seguir depois da linha de descrição que diz <description>Demo project for Spring Boot</description>.

1. Adicione spring-boot-devtools em pom.xml

Abra o pom.xml na raiz do projeto. Adicione a seguinte configuração após a entrada Description.

pom.xml

  <!--  Spring profiles-->
  <profiles>
    <profile>
      <id>sync</id>
      <dependencies>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-devtools</artifactId>
        </dependency>
      </dependencies>
    </profile>
  </profiles>

2. Ativar o jib-maven-plugin em pom.xml

O Jib é uma ferramenta de contêinerização Java de código aberto do Google que permite aos desenvolvedores Java criar contêineres usando as ferramentas Java que eles conhecem. O Jib é um criador de imagens de contêiner rápido e simples que lida com todas as etapas de empacotamento do aplicativo em uma imagem de contêiner. Não é necessário escrever um Dockerfile nem ter o Docker instalado, e ele é integrado diretamente ao Maven e ao Gradle.

Role a tela para baixo no arquivo pom.xml e atualize a seção Build para incluir o plug-in Jib. A seção de build precisa corresponder ao seguinte quando concluída.

pom.xml

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
      <!--  Jib Plugin-->
      <plugin>
        <groupId>com.google.cloud.tools</groupId>
        <artifactId>jib-maven-plugin</artifactId>
        <version>3.2.0</version>
      </plugin>
       <!--  Maven Resources Plugin-->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <version>3.1.0</version>
      </plugin>
    </plugins>
  </build>

Escolha Always se for solicitado a mudar o arquivo de build.

Gerar manifestos

O Skaffold oferece ferramentas integradas para simplificar o desenvolvimento de contêineres. Nesta etapa, você vai inicializar o skaffold, que vai criar automaticamente arquivos YAML básicos do Kubernetes. O processo tenta identificar diretórios com definições de imagens de contêiner, como um Dockerfile, e cria um manifesto de implantação e serviço para cada um.

Execute o comando abaixo para iniciar o processo.

1. Execute o comando a seguir no terminal:

skaffold init --generate-manifests

2. Quando solicitado:

• Use as setas para mover o cursor até Jib Maven Plugin
• Pressione a barra de espaço para selecionar a opção.
• Pressione Enter para continuar

3. Insira 8080 para a porta
4. Digite y para salvar a configuração.

Dois arquivos são adicionados à visualização do espaço de trabalho: skaffold.yaml e deployment.yaml.

Atualizar nome do app

Os valores padrão incluídos na configuração não correspondem ao nome do seu aplicativo. Atualize os arquivos para fazer referência ao nome do aplicativo em vez dos valores padrão.

1. Mudar entradas na configuração do Skaffold

• Abrir skaffold.yaml
• Selecione o nome da imagem definido como pom-xml-image.
• Clique com o botão direito do mouse e escolha "Mudar todas as ocorrências".
• Digite o novo nome como demo-app

2. Mudar entradas na configuração do Kubernetes

• Abrir arquivo deployment.yaml
• Selecione o nome da imagem definido como pom-xml-image.
• Clique com o botão direito do mouse e escolha "Mudar todas as ocorrências".
• Digite o novo nome como demo-app

Ativar sincronização rápida

Para facilitar uma experiência otimizada de recarga automática, use o recurso de sincronização fornecido pelo Jib. Nesta etapa, você vai configurar o Skaffold para usar esse recurso no processo de build.

O perfil "sync" que você está configurando na configuração do skaffold usa o perfil "sync" do Spring que você configurou na etapa anterior, em que ativou o suporte para spring-dev-tools.

1. Atualizar configuração do skaffold

No arquivo skaffold.yaml, substitua toda a seção de build pela seguinte especificação. Não altere outras seções do arquivo.

skaffold.yaml

build:
  artifacts:
  - image: demo-app
    jib:
      project: com.example:demo
      type: maven
      args: 
      - --no-transfer-progress
      - -Psync
      fromImage: gcr.io/distroless/java:debug
    sync:
      auto: true

Adicionar uma rota padrão

Crie um arquivo chamado HelloController.java em /src/main/java/com/example/springboot/.

Cole o conteúdo a seguir no arquivo para criar uma rota HTTP padrão.

HelloController.java

package com.example.springboot;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Value;

@RestController
public class HelloController {

    @Value("${target:local}")
    String target;

    @GetMapping("/") 
    public String hello()
    {
        return String.format("Hello from your %s environment!", target);
    }
}

4. Como percorrer o processo de desenvolvimento

Nesta seção, você vai seguir algumas etapas usando o plug-in Cloud Code para aprender os processos básicos e validar a configuração e a instalação do aplicativo inicial.

O Cloud Code se integra ao Skaffold para simplificar seu processo de desenvolvimento. Ao implantar no GKE nas etapas a seguir, o Cloud Code e o Skaffold vão criar automaticamente a imagem do contêiner, enviá-la para um Container Registry e implantar o aplicativo no GKE. Isso acontece nos bastidores, abstraindo os detalhes do fluxo do desenvolvedor. O Cloud Code também melhora seu processo de desenvolvimento ao oferecer recursos tradicionais de depuração e hotsync para desenvolvimento baseado em contêineres.

Implantar no Kubernetes

1. No painel na parte de baixo do editor do Cloud Shell, selecione Cloud Code 

2. No painel que aparece na parte de cima, selecione "Depurar no Kubernetes". Se solicitado, selecione "Sim" para usar o contexto atual do Kubernetes.

3. Na primeira vez que você executar o comando, uma solicitação vai aparecer na parte de cima da tela perguntando se você quer o contexto atual do Kubernetes. Selecione "Sim" para aceitar e usar o contexto atual.

4. Em seguida, uma solicitação vai aparecer perguntando qual registro de contêiner usar. Pressione "Enter" para aceitar o valor padrão fornecido.

5. Selecione a guia "Saída" no painel de baixo para conferir o progresso e as notificações.

6. Selecione "Kubernetes: Run/Debug - Detailed" no menu suspenso do canal à direita para conferir mais detalhes e registros transmitidos ao vivo dos contêineres.

7. Para voltar à visualização simplificada, selecione "Kubernetes: Run/Debug" no menu suspenso.
8. Quando o build e os testes forem concluídos, a guia "Saída" vai mostrar: Resource deployment/demo-app status completed successfully, e um URL será listado: "URL encaminhado do app de demonstração do serviço: http://localhost:8080"
9. No terminal do Cloud Code, passe o cursor sobre o URL na saída (http://localhost:8080) e, na dica de ferramenta que aparece, selecione "Abrir visualização na Web".

A resposta será:

Hello from your local environment!

Usar pontos de interrupção

1. Abra o aplicativo HelloController.java localizado em /src/main/java/com/example/springboot/HelloController.java
2. Localize a instrução de retorno do caminho raiz, que diz return String.format("Hello from your %s environment!", target);.
3. Adicione um ponto de interrupção a essa linha clicando no espaço em branco à esquerda do número da linha. Um indicador vermelho vai aparecer para mostrar que o ponto de interrupção foi definido.
4. Recarregue o navegador e observe que o depurador interrompe o processo no ponto de interrupção e permite investigar o estado da variável e do aplicativo que está sendo executado remotamente no GKE.
5. Clique na seção de variáveis até encontrar a variável "Destino".
6. Observe o valor atual como "local".
7. Clique duas vezes no nome da variável "target" e, no pop-up, mude o valor para algo diferente, como "Cloud".
8. Clique no botão "Continuar" no painel de controle de depuração.
9. Revise a resposta no navegador, que agora mostra o valor atualizado que você acabou de inserir.

Recarga automática

1. Mude a instrução para retornar um valor diferente, como "Olá do código %s".
2. O arquivo é salvo e sincronizado automaticamente nos contêineres remotos no GKE.
3. Atualize o navegador para ver os resultados atualizados.
4. Clique no quadrado vermelho na barra de ferramentas de depuração para interromper a sessão.

5. Como desenvolver um serviço REST CRUD simples

Neste ponto, seu aplicativo está totalmente configurado para desenvolvimento em contêineres, e você já passou pelo fluxo de trabalho de desenvolvimento básico com o Cloud Code. Nas seções a seguir, você vai praticar o que aprendeu adicionando endpoints de serviço REST que se conectam a um banco de dados gerenciado no Google Cloud.

Configurar dependências

O código do aplicativo usa um banco de dados para manter os dados do serviço REST. Adicione o seguinte ao pom.xl para garantir que as dependências estejam disponíveis:

1. Abra o arquivo pom.xml e adicione o seguinte à seção de dependências da configuração:

pom.xml

    <!--  Database dependencies-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>org.postgresql</groupId>
      <artifactId>postgresql</artifactId>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>org.flywaydb</groupId>
      <artifactId>flyway-core</artifactId>
    </dependency>

Codificar o serviço restante

Quote.java

Crie um arquivo chamado Quote.java em /src/main/java/com/example/springboot/ e copie o código abaixo. Isso define o modelo de entidade para o objeto "Quote" usado no aplicativo.

package com.example.springboot;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Objects;

@Entity
@Table(name = "quotes")
public class Quote
{
    @Id
    @Column(name = "id")
    private Integer id;

    @Column(name="quote")
    private String quote;

    @Column(name="author")
    private String author;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getQuote() {
        return quote;
    }

    public void setQuote(String quote) {
        this.quote = quote;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    @Override
    public boolean equals(Object o) {
      if (this == o) {
        return true;
      }
      if (o == null || getClass() != o.getClass()) {
        return false;
      }
        Quote quote1 = (Quote) o;
        return Objects.equals(id, quote1.id) &&
                Objects.equals(quote, quote1.quote) &&
                Objects.equals(author, quote1.author);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, quote, author);
    }
}

QuoteRepository.java

Crie um arquivo chamado QuoteRepository.java em src/main/java/com/example/springboot e copie o seguinte código:

package com.example.springboot;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

public interface QuoteRepository extends JpaRepository<Quote,Integer> {

    @Query( nativeQuery = true, value =
            "SELECT id,quote,author FROM quotes ORDER BY RANDOM() LIMIT 1")
    Quote findRandomQuote();
}

Esse código usa JPA para persistir os dados. A classe estende a interface JPARepository do Spring e permite a criação de código personalizado. No código, você adicionou um método personalizado findRandomQuote.

QuoteController.java

Para expor o endpoint do serviço, uma classe QuoteController vai fornecer essa funcionalidade.

Crie um arquivo chamado QuoteController.java em src/main/java/com/example/springboot e copie o seguinte conteúdo:

package com.example.springboot;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class QuoteController {

    private final QuoteRepository quoteRepository;

    public QuoteController(QuoteRepository quoteRepository) {
        this.quoteRepository = quoteRepository;
    }

    @GetMapping("/random-quote") 
    public Quote randomQuote()
    {
        return quoteRepository.findRandomQuote();  
    }

    @GetMapping("/quotes") 
    public ResponseEntity<List<Quote>> allQuotes()
    {
        try {
            List<Quote> quotes = new ArrayList<Quote>();
            
            quoteRepository.findAll().forEach(quotes::add);

            if (quotes.size()==0 || quotes.isEmpty()) 
                return new ResponseEntity<List<Quote>>(HttpStatus.NO_CONTENT);
                
            return new ResponseEntity<List<Quote>>(quotes, HttpStatus.OK);
        } catch (Exception e) {
            System.out.println(e.getMessage());
            return new ResponseEntity<List<Quote>>(HttpStatus.INTERNAL_SERVER_ERROR);
        }        
    }

    @PostMapping("/quotes")
    public ResponseEntity<Quote> createQuote(@RequestBody Quote quote) {
        try {
            Quote saved = quoteRepository.save(quote);
            return new ResponseEntity<Quote>(saved, HttpStatus.CREATED);
        } catch (Exception e) {
            System.out.println(e.getMessage());
            return new ResponseEntity<Quote>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }     

    @PutMapping("/quotes/{id}")
    public ResponseEntity<Quote> updateQuote(@PathVariable("id") Integer id, @RequestBody Quote quote) {
        try {
            Optional<Quote> existingQuote = quoteRepository.findById(id);
            
            if(existingQuote.isPresent()){
                Quote updatedQuote = existingQuote.get();
                updatedQuote.setAuthor(quote.getAuthor());
                updatedQuote.setQuote(quote.getQuote());

                return new ResponseEntity<Quote>(updatedQuote, HttpStatus.OK);
            } else {
                return new ResponseEntity<Quote>(HttpStatus.NOT_FOUND);
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
            return new ResponseEntity<Quote>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }     

    @DeleteMapping("/quotes/{id}")
    public ResponseEntity<HttpStatus> deleteQuote(@PathVariable("id") Integer id) {
        try {
            quoteRepository.deleteById(id);
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        } catch (RuntimeException e) {
            System.out.println(e.getMessage());
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }    
}

Adicionar configurações de banco de dados

application.yaml

Adicione a configuração do banco de dados de back-end acessado pelo serviço. Edite (ou crie, se não estiver presente) o arquivo chamado application.yaml em src/main/resources e adicione uma configuração Spring parametrizada para o back-end.

target: local

spring:
  config:
    activate:
      on-profile: cloud-dev
  datasource:
    url: 'jdbc:postgresql://${DB_HOST:127.0.0.1}/${DB_NAME:quote_db}'
    username: '${DB_USER:user}'
    password: '${DB_PASS:password}'
  jpa:
    properties:
      hibernate:
        jdbc:
          lob:
            non_contextual_creation: true
        dialect: org.hibernate.dialect.PostgreSQLDialect
    hibernate:
      ddl-auto: update

Adicionar migração de banco de dados

Crie uma pasta em src/main/resources/db/migration/

Crie um arquivo SQL: V1__create_quotes_table.sql

Cole o conteúdo a seguir no arquivo:

V1__create_quotes_table.sql

CREATE TABLE quotes(
   id INTEGER PRIMARY KEY,
   quote VARCHAR(1024),
   author VARCHAR(256)
);

INSERT INTO quotes (id,quote,author) VALUES (1,'Never, never, never give up','Winston Churchill');
INSERT INTO quotes (id,quote,author) VALUES (2,'While there''s life, there''s hope','Marcus Tullius Cicero');
INSERT INTO quotes (id,quote,author) VALUES (3,'Failure is success in progress','Anonymous');
INSERT INTO quotes (id,quote,author) VALUES (4,'Success demands singleness of purpose','Vincent Lombardi');
INSERT INTO quotes (id,quote,author) VALUES (5,'The shortest answer is doing','Lord Herbert');

Configuração do Kubernetes

As adições a seguir no arquivo deployment.yaml permitem que o aplicativo se conecte às instâncias do Cloud SQL.

• TARGET: configura a variável para indicar o ambiente em que o app é executado.
• SPRING_PROFILES_ACTIVE: mostra o perfil ativo do Spring, que será configurado como cloud-dev.
• DB_HOST: o IP privado do banco de dados, que foi anotado quando a instância do banco de dados foi criada ou ao clicar em SQL no menu de navegação do console do Google Cloud. Mude o valor.
• DB_USER e DB_PASS: conforme definido na configuração da instância do Cloud SQL, armazenados como um secret no GCP.

Atualize o arquivo deployment.yaml com o conteúdo abaixo.

deployment.yaml

apiVersion: v1
kind: Service
metadata:
  name: demo-app
  labels:
    app: demo-app
spec:
  ports:
  - port: 8080
    protocol: TCP
  clusterIP: None
  selector:
    app: demo-app
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: demo-app
  labels:
    app: demo-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: demo-app
  template:
    metadata:
      labels:
        app: demo-app
    spec:
      containers:
      - name: demo-app
        image: demo-app
        env:
          - name: PORT
            value: "8080"
          - name: TARGET
            value: "Local Dev - CloudSQL Database - K8s Cluster"
          - name: SPRING_PROFILES_ACTIVE
            value: cloud-dev
          - name: DB_HOST
            value: ${DB_INSTANCE_IP}   
          - name: DB_PORT
            value: "5432"  
          - name: DB_USER
            valueFrom:
              secretKeyRef:
                name: gke-cloud-sql-secrets
                key: username
          - name: DB_PASS
            valueFrom:
              secretKeyRef:
                name: gke-cloud-sql-secrets
                key: password
          - name: DB_NAME
            valueFrom:
              secretKeyRef:
                name: gke-cloud-sql-secrets
                key: database 

Substitua o valor DB_HOST pelo endereço do seu banco de dados.

export DB_INSTANCE_IP=$(gcloud sql instances describe quote-db-instance \
    --format=json | jq \
    --raw-output ".ipAddresses[].ipAddress")

envsubst < deployment.yaml > deployment.new && mv deployment.new deployment.yaml

Implantar e validar o aplicativo

1. No painel na parte de baixo do editor do Cloud Shell, selecione "Cloud Code" e depois "Depurar no Kubernetes" na parte de cima da tela.
2. Quando o build e os testes forem concluídos, a guia "Saída" vai mostrar: Resource deployment/demo-app status completed successfully, e um URL será listado: "URL encaminhado do app de demonstração do serviço: http://localhost:8080"
3. Ver citações aleatórias

No terminal do Cloud Shell, execute o comando abaixo várias vezes no endpoint random-quote. Observe a chamada repetida retornando cotações diferentes

curl -v 127.0.0.1:8080/random-quote

4. Adicionar uma citação

Crie uma nova cotação com id=6 usando o comando listado abaixo e observe a solicitação sendo repetida.

curl -v -H 'Content-Type: application/json' -d '{"id":"6","author":"Henry David Thoreau","quote":"Go confidently in the direction of your dreams! Live the life you have imagined"}' -X POST 127.0.0.1:8080/quotes

5. Excluir uma cotação

Agora exclua a citação que você acabou de adicionar com o método de exclusão e observe um código de resposta HTTP/1.1 204.

curl -v -X DELETE 127.0.0.1:8080/quotes/6

6. Erro no servidor

Apresentar um estado de erro executando a última solicitação novamente depois que a entrada já foi excluída

curl -v -X DELETE 127.0.0.1:8080/quotes/6

A resposta retorna um HTTP:500 Internal Server Error.

Depurar o aplicativo

Na seção anterior, você encontrou um estado de erro no aplicativo ao tentar excluir uma entrada que não estava no banco de dados. Nesta seção, você vai definir um ponto de interrupção para localizar o problema. O erro ocorreu na operação DELETE, então você vai trabalhar com a classe QuoteController.

1. Abra src.main.java.com.example.springboot.QuoteController.java
2. Encontre o método deleteQuote()
3. Encontre a linha em que um item é excluído do banco de dados: quoteRepository.deleteById(id);
4. Defina um ponto de interrupção nessa linha clicando no espaço em branco à esquerda do número da linha.
5. Um indicador vermelho vai aparecer para mostrar que o ponto de interrupção foi definido.
6. Execute o comando delete novamente.

curl -v -X DELETE 127.0.0.1:8080/quotes/6

7. Clique no ícone na coluna à esquerda para voltar à visualização de depuração.
8. Observe a linha de depuração interrompida na classe QuoteController.
9. No depurador, clique no ícone step over e observe que uma exceção é gerada.
10. Observe que um RuntimeException was caught. muito genérico retorna um erro interno do servidor HTTP 500 ao cliente, o que não é o ideal.

   Trying 127.0.0.1:8080...
* Connected to 127.0.0.1 (127.0.0.1) port 8080 (#0)
> DELETE /quotes/6 HTTP/1.1
> Host: 127.0.0.1:8080
> User-Agent: curl/7.74.0
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 500
< Content-Length: 0
< Date: 
<
* Connection #0 to host 127.0.0.1 left intact

Atualizar o código

O código está incorreto, e o bloco de exceção precisa ser refatorado para capturar a exceção EmptyResultDataAccessException e enviar de volta um código de status HTTP 404 não encontrado.

Corrija o erro.

1. Com a sessão de depuração ainda em execução, conclua a solicitação pressionando o botão "Continuar" no painel de controle de depuração.
2. Em seguida, adicione o seguinte bloco ao código:

       } catch (EmptyResultDataAccessException e){
            return new ResponseEntity<HttpStatus>(HttpStatus.NOT_FOUND);
        }

O método vai ficar assim:

    public ResponseEntity<HttpStatus> deleteQuote(@PathVariable("id") Integer id) {
        try {
            quoteRepository.deleteById(id);
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        } catch(EmptyResultDataAccessException e){
            return new ResponseEntity<HttpStatus>(HttpStatus.NOT_FOUND);
        } catch (RuntimeException e) {
            System.out.println(e.getMessage());
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

3. Execute o comando de exclusão novamente.

curl -v -X DELETE 127.0.0.1:8080/quotes/6

4. Percorra o depurador e observe o EmptyResultDataAccessException sendo capturado e um HTTP 404 Não encontrado retornado ao autor da chamada.

   Trying 127.0.0.1:8080...
* Connected to 127.0.0.1 (127.0.0.1) port 8080 (#0)
> DELETE /quotes/6 HTTP/1.1
> Host: 127.0.0.1:8080
> User-Agent: curl/7.74.0
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 404
< Content-Length: 0
< Date: 
<
* Connection #0 to host 127.0.0.1 left intact

5. Clique no quadrado vermelho na barra de ferramentas de depuração para interromper a sessão.

6. Limpeza

Parabéns! Neste laboratório, você criou um novo aplicativo Java do zero e o configurou para funcionar de maneira eficaz com contêineres. Em seguida, você implantou e depurou o aplicativo em um cluster do GKE remoto seguindo o mesmo fluxo de desenvolvedor encontrado em stacks de aplicativos tradicionais.

Para fazer a limpeza depois de concluir o laboratório:

1. Excluir os arquivos usados no laboratório

cd ~ && rm -rf container-developer-workshop

2. Exclua o projeto para remover toda a infraestrutura e os recursos relacionados.