Exercício - Codifique 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 esse acesso ao banco de dados no futuro. Mas primeiro vamos criar a infraestrutura do aplicativo e, em seguida, configurar o aplicativo Java para usar.

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 seu aplicativo.
  • Um servidor de banco de dados PostgreSQL.
  • Um cluster do Azure Spring Apps e um aplicativo Spring Boot em execução dentro desse 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 do seu computador local. Este endereço IP deve ser um endereço IPv4. Se não souber o seu endereço IP local, pode aceder ao seguinte Web 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 estiverem 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

Este comando pode demorar vários minutos a concluir.

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

Este comando pode demorar vários minutos a concluir.

az extension add --name spring

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

Este comando pode demorar vários minutos a concluir.

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, então você pode deixá-los ser executados em segundo plano e começar a codificar o aplicativo enquanto isso.

Configurar a aplicação Java

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

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

Esta aplicação utiliza Spring Data JPA para aceder à base de dados. Você pode olhar para 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 então expostos à Web, usando um controlador REST Spring MVC:

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();
    }
}

Estes dados são inseridos na base de dados no momento do arranque, utilizando o src/main/resources/data.sql ficheiro:

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

Você pode adicionar mais linhas a esse arquivo se quiser mais dados ou se quiser personalizá-lo.

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

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

Este 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 AZ_DATABASE_NAME variável de ambiente. 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 AZ_DATABASE_USERNAME variável de ambiente. Digite echo $AZ_DATABASE_USERNAME para vê-lo.
  • ${azureDatabasePassword} é o nome da senha do banco de dados que foi configurada anteriormente na AZ_DATABASE_PASSWORD variável de ambiente. 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 escrevê-los temporariamente e executar o aplicativo:

./mvnw spring-boot:run

Você pode ler o conteúdo do banco de dados acessando o Spring MVC Controller usando o seguinte comando ou usando 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 target diretório, 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, você pode examinar os logs do aplicativo digitando o seguinte comando:

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

O aplicativo estará disponível na nuvem e você poderá acessar seus dados usando um comando 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 sucesso 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.