Exercício – Codificar um aplicativo Java que usa segredos

  • 5 minutos

Você vai codificar um aplicativo Web Java, usando o Spring Boot, que se conecta a um banco de dados.

Por motivos de segurança, você precisará proteger o acesso a esse banco de dados no futuro. Mas primeiro, vamos criar a infraestrutura do aplicativo e configurar o aplicativo Java a ser usado.

Criar a infraestrutura do aplicativo

Neste exercício, você usa a CLI do Azure para criar os seguintes recursos:

  • Um grupo de recursos do Azure que contém todos os recursos para o seu aplicativo.
  • Um servidor de banco de dados PostgreSQL.
  • Um cluster dos Aplicativos Spring do Azure e um aplicativo do Spring Boot em execução dentro deste cluster.

Você precisa fornecer algumas variáveis de ambiente no início do script que devem ser exclusivas no Azure.

Você também precisa fornecer seu endereço IP local para acessar o banco de dados no computador local. Esse endereço IP deve ser um endereço IPv4. Se você não sabe seu endereço IP local, acesse o seguinte site: https://www.whatismyip.com/

Defina as seguintes variáveis de ambiente:

AZ_RESOURCE_GROUP=<YOUR_UNIQUE_RESOURCE_GROUP_NAME>
AZ_DATABASE_USERNAME=<YOUR_POSTGRESQL_USERNAME>
AZ_DATABASE_PASSWORD=<YOUR_POSTGRESQL_PASSWORD>
AZ_LOCAL_IP_ADDRESS=<YOUR_LOCAL_IP_ADDRESS>

Depois que essas variáveis de ambiente forem definidas, você poderá executar o seguinte comando para criar os recursos:

AZ_LOCATION=eastus
# Must be all lowercase
AZ_SPRING_CLOUD=spring-${AZ_RESOURCE_GROUP,,}

AZ_DATABASE_NAME=pgsql-${AZ_RESOURCE_GROUP}
AZ_DATABASE_USERNAME=${AZ_DATABASE_USERNAME}

az group create \
    --name $AZ_RESOURCE_GROUP \
    --location $AZ_LOCATION

Esse comando pode levar vários minutos para ser concluído.

az postgres server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME \
    --location $AZ_LOCATION \
    --sku-name B_Gen5_1 \
    --storage-size 5120 \
    --admin-user $AZ_DATABASE_USERNAME \
    --admin-password $AZ_DATABASE_PASSWORD

az postgres server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME-database-allow-local-ip \
    --server $AZ_DATABASE_NAME \
    --start-ip-address $AZ_LOCAL_IP_ADDRESS \
    --end-ip-address $AZ_LOCAL_IP_ADDRESS

az postgres server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME-database-allow-azure-ip \
    --server $AZ_DATABASE_NAME \
    --start-ip-address 0.0.0.0 \
    --end-ip-address 0.0.0.0

az postgres db create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name demo \
    --server-name $AZ_DATABASE_NAME

Esse comando pode levar vários minutos para ser concluído.

az extension add --name spring

az spring create \
   --name $AZ_SPRING_CLOUD \
   --resource-group $AZ_RESOURCE_GROUP \
   --location $AZ_LOCATION \
   --sku Basic

Esse comando pode levar vários minutos para ser concluído.

az spring app create \
   --resource-group $AZ_RESOURCE_GROUP \
   --service $AZ_SPRING_CLOUD \
   --name application \
   --runtime-version Java_11 \
   --assign-endpoint true

Esses scripts levam algum tempo para serem executados, para que você possa permitir que eles sejam executados em segundo plano e começar a codificar o aplicativo enquanto isso.

Configurar o aplicativo Java

Obtenha o esqueleto do aplicativo no repositório GitHub https://github.com/Azure-Samples/manage-secrets-in-java-applications usando o comando git clone:

git clone https://github.com/Azure-Samples/manage-secrets-in-java-applications.git

Este aplicativo usa o Spring Data JPA para acessar o banco de dados. Você pode examinar a interface do repositório CRUD:

package com.example.demo;

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface ItemRepository extends CrudRepository<Item, Integer> {
}

Os dados armazenados no banco de dados são expostos à Web por meio de um Controlador Spring MVC REST:

package com.example.demo;

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

@RestController
public class ItemController {

    private final ItemRepository itemRepository;

    public ItemController(ItemRepository itemRepository) {
        this.itemRepository = itemRepository;
    }

    @GetMapping("/")
    String welcome() {
        return "Here are all the database items: " + itemRepository.findAll();
    }
}

Esses dados são inseridos no banco de dados no momento da inicialização, por meio do arquivo src/main/resources/data.sql:

insert into item (details) values ('This is a item from the database');

Você poderá adicionar mais linhas a esse arquivo se quiser ter mais dados ou personalizá-los.

Para acessar o banco de dados, você precisa configurar o arquivo src/main/resources/application.properties:

logging.level.org.springframework.jdbc.core=DEBUG

spring.datasource.url=jdbc:postgresql://${azureDatabaseName}.postgres.database.azure.com:5432/demo
spring.datasource.username=${azureDatabaseUsername}@${azureDatabaseName}
spring.datasource.password=${azureDatabasePassword}

spring.sql.init.mode=always

Esse arquivo de configuração tem três variáveis que precisam ser configuradas:

  • ${azureDatabaseName} é o nome do banco de dados PostgreSQL que foi configurado anteriormente na variável de ambiente AZ_DATABASE_NAME. Digite echo $AZ_DATABASE_NAME para vê-lo.
  • ${azureDatabaseUsername} é o nome do nome de usuário do banco de dados que foi configurado anteriormente na variável de ambiente AZ_DATABASE_USERNAME. Digite echo $AZ_DATABASE_USERNAME para vê-lo.
  • ${azureDatabasePassword} é o nome da senha do banco de dados que foi configurada anteriormente na variável de ambiente AZ_DATABASE_PASSWORD. Digite echo $AZ_DATABASE_PASSWORD para vê-lo.

Como vimos na unidade anterior, é uma má prática codificar esses valores no código-fonte do aplicativo. Mas para testar o aplicativo, você pode gravá-los temporariamente e executar o aplicativo:

./mvnw spring-boot:run

Leia o conteúdo do banco de dados acessando o Controlador Spring MVC usando o seguinte comando ou um navegador da Web:

curl http://localhost:8080

Implantar o aplicativo Java no Azure

Para implantar o aplicativo, primeiro você precisa empacotá-lo como um arquivo Jar:

./mvnw clean package

Este comando produz um arquivo Jar executável no diretório target que você implanta usando a CLI do Azure:

az spring app deploy \
   --resource-group $AZ_RESOURCE_GROUP \
   --service $AZ_SPRING_CLOUD \
   --name application \
   --artifact-path target/*.jar

Se você encontrar falhas, poderá examinar os logs do aplicativo digitando o seguinte comando:

az spring app logs \
   --resource-group $AZ_RESOURCE_GROUP \
   --service $AZ_SPRING_CLOUD \
   --name application

Em seguida, o aplicativo ficará disponível na nuvem, e você poderá acessar os dados dele usando um comando do cURL:

curl https://$AZ_SPRING_CLOUD-application.azuremicroservices.io

# Expected output:
#
# Here are all the database items: [Secret{Id=1, details='This is a item from the database'}]
#

Parabéns! Você criou com êxito um aplicativo Java que se conecta a um banco de dados! Agora você precisa proteger as credenciais do banco de dados nas próximas unidades.