Usar o Spring Data R2DBC com o Banco de Dados do Azure para PostgreSQL

Artigo
11/25/2024

Este artigo demonstra como criar um aplicativo de exemplo que usa o Spring Data R2DBC para armazenar e recuperar informações em um banco de dados do Banco de Dados do Azure para PostgreSQL. O exemplo usará a implementação R2DBC para PostgreSQL no repositório r2dbc-postgresql no GitHub.

O R2DBC traz APIs reativas para bancos de dados relacionais tradicionais. Você pode usá-lo com o Spring WebFlux para criar aplicativos Spring Boot totalmente reativos que usam APIs sem bloqueio. Ele fornece melhor escalabilidade do que a abordagem clássica "um thread por conexão".

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente.
Java Development Kit (JDK), versão 8 ou superior.
Apache Maven.
CLI do Azure.

Cliente de linha de comando do PostgreSQL.
O cURL ou um utilitário HTTP semelhante para testar a funcionalidade.

Consulte o aplicativo de exemplo

Neste artigo, você codificará um aplicativo de exemplo. Caso você queira adiantar o processo, esse aplicativo já está codificado e disponível em https://github.com/Azure-Samples/quickstart-spring-data-r2dbc-postgresql.

Preparar o ambiente de trabalho

Primeiro, configure algumas variáveis de ambiente executando os seguintes comandos:

export AZ_RESOURCE_GROUP=database-workshop
export AZ_DATABASE_SERVER_NAME=<YOUR_DATABASE_SERVER_NAME>
export AZ_DATABASE_NAME=<YOUR_DATABASE_NAME>
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_POSTGRESQL_ADMIN_USERNAME=spring
export AZ_POSTGRESQL_ADMIN_PASSWORD=<YOUR_POSTGRESQL_ADMIN_PASSWORD>
export AZ_POSTGRESQL_NON_ADMIN_USERNAME=nonspring
export AZ_POSTGRESQL_NON_ADMIN_PASSWORD=<YOUR_POSTGRESQL_NON_ADMIN_PASSWORD>
export AZ_LOCAL_IP_ADDRESS=<YOUR_LOCAL_IP_ADDRESS>

Substitua os espaços reservados pelos seguintes valores, que são usados em todo este artigo:

<YOUR_DATABASE_SERVER_NAME>: o nome do servidor PostgreSQL, que deve ser exclusivo no Azure.
<YOUR_DATABASE_NAME>: o nome do banco de dados do servidor PostgreSQL, que deve ser exclusivo no Azure.
<YOUR_AZURE_REGION>: A região do Azure que você usará. Você pode usar eastus por padrão, mas é recomendável configurar uma região mais próxima de onde você mora. Você pode ver a lista completa de regiões disponíveis usando az account list-locationso .
<YOUR_POSTGRESQL_ADMIN_PASSWORD> e <YOUR_POSTGRESQL_NON_ADMIN_PASSWORD>: A senha do seu servidor de banco de dados PostgreSQL, que deve ter no mínimo oito caracteres. Os caracteres deveriam ser de três das seguintes categorias: Letras maiúsculas, letras minúsculas, números (0-9) e caracteres não alfanuméricos (!, $, #, % e assim por diante).
<YOUR_LOCAL_IP_ADDRESS>: O endereço IP do computador local, do qual você executará o aplicativo Spring Boot. Uma forma conveniente de encontrá-lo é abrir whatismyip.akamai.com.

Observação

A Microsoft recomenda usar o fluxo de autenticação mais seguro disponível. O fluxo de autenticação descrito neste procedimento, como bancos de dados, caches, mensagens ou serviços de IA, requer um grau muito alto de confiança no aplicativo e traz riscos não presentes em outros fluxos. Use esse fluxo somente quando opções mais seguras, como identidades gerenciadas para conexões sem senha ou sem chave, não forem viáveis. Para operações de computador local, prefira identidades de usuário para conexões sem senha ou sem chave.

Em seguida, crie um grupo de recursos usando o seguinte comando:

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

Criar uma instância do Banco de Dados do Azure para PostgreSQL e configurar o usuário administrador

A primeira coisa que você vai criar é um servidor PostgreSQL gerenciado com um usuário administrador.

Observação

Você pode ler informações mais detalhadas sobre como criar servidores PostgreSQL em Criar um servidor do Banco de Dados do Azure para PostgreSQL usando o portal do Azure.

az postgres flexible-server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME \
    --location $AZ_LOCATION \
    --admin-user $AZ_POSTGRESQL_ADMIN_USERNAME \
    --admin-password $AZ_POSTGRESQL_ADMIN_PASSWORD \
    --yes \
    --output tsv

Configurar um banco de dados PostgreSQL

O servidor PostgreSQL que você criou anteriormente está vazio. Use o comando a seguir para criar um banco de dados.

az postgres flexible-server db create \
    --resource-group $AZ_RESOURCE_GROUP \
    --database-name $AZ_DATABASE_NAME \
    --server-name $AZ_DATABASE_SERVER_NAME \
    --output tsv

Configurar uma regra de firewall para o servidor PostgreSQL

As instâncias do Banco de Dados do Azure para PostgreSQL são protegidas por padrão. Elas têm um firewall que não permite nenhuma conexão de entrada. Para usar o banco de dados, você precisa adicionar uma regra de firewall que permitirá que o endereço IP local acesse o servidor de banco de dados.

Como você configurou seu endereço IP local no início deste artigo, abra o firewall do servidor executando o seguinte comando:

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

Se você estiver se conectando ao servidor PostgreSQL do WSL (Subsistema do Windows para Linux) em um computador Windows, será necessário adicionar a ID do host WSL ao firewall.

Obtenha o endereço IP do computador host executando o seguinte comando no WSL:

cat /etc/resolv.conf

Copie o endereço IP após o termo nameserver e use o seguinte comando para definir uma variável de ambiente para o endereço IP WSL:

export AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

Em seguida, use o seguinte comando para abrir o firewall do servidor para seu aplicativo baseado em WSL:

az postgres flexible-server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME \
    --rule-name $AZ_DATABASE_SERVER_NAME-database-allow-local-ip \
    --start-ip-address $AZ_WSL_IP_ADDRESS \
    --end-ip-address $AZ_WSL_IP_ADDRESS \
    --output tsv

Criar um usuário não administrador do PostgreSQL e conceder permissão

Em seguida, crie um usuário não administrador e conceda a ele todas as permissões para o banco de dados.

Observação

Você pode ler informações mais detalhadas sobre como criar usuários do PostgreSQL em Criar usuários no Banco de Dados do Azure para PostgreSQL.

Crie um script SQL chamado create_user.sql para criar um usuário não administrador. Adicione o seguinte conteúdo e salve-o localmente:

Observação

cat << EOF > create_user.sql
CREATE ROLE "$AZ_POSTGRESQL_NON_ADMIN_USERNAME" WITH LOGIN PASSWORD '$AZ_POSTGRESQL_NON_ADMIN_PASSWORD';
GRANT ALL PRIVILEGES ON DATABASE $AZ_DATABASE_NAME TO "$AZ_POSTGRESQL_NON_ADMIN_USERNAME";
EOF

Em seguida, use o seguinte comando para executar o script SQL, a fim de criar o usuário não administrador do Microsoft Entra:

psql "host=$AZ_DATABASE_SERVER_NAME.postgres.database.azure.com user=$AZ_POSTGRESQL_ADMIN_USERNAME dbname=$AZ_DATABASE_NAME port=5432 password=$AZ_POSTGRESQL_ADMIN_PASSWORD sslmode=require" < create_user.sql

Agora, use o seguinte comando para remover o arquivo de script SQL temporário:

rm create_user.sql

Criar um aplicativo Spring Boot reativo

Para criar um aplicativo Spring Boot reativo, usaremos o Spring Initializr. O aplicativo que criaremos usa:

Bota de mola 2.7.11.
As seguintes dependências: Spring Reactive Web (também conhecido como Spring WebFlux) e Spring Data R2DBC.

Gerar o aplicativo usando o Spring Initializr

Gere o aplicativo na linha de comando usando o seguinte comando:

curl https://start.spring.io/starter.tgz -d dependencies=webflux,data-r2dbc -d baseDir=azure-database-workshop -d bootVersion=2.7.11 -d javaVersion=17 | tar -xzvf -

Adicionar a implementação do driver PostgreSQL reativo

Abra o arquivo pom.xml do projeto gerado e adicione o driver PostgreSQL reativo do repositório no GitHub r2dbc-postgresql. Após a dependência spring-boot-starter-webflux, adicione o seguinte texto:

<dependency>
    <groupId>io.r2dbc</groupId>
    <artifactId>r2dbc-postgresql</artifactId>
    <version>0.8.12.RELEASE</version>
    <scope>runtime</scope>
</dependency>

Configurar o Spring Boot para usar o Banco de Dados do Azure para PostgreSQL

Abra o arquivo src/main/resources/application.properties e adicione o seguinte texto:

logging.level.org.springframework.data.r2dbc=DEBUG

spring.r2dbc.url=r2dbc:pool:postgres://$AZ_DATABASE_SERVER_NAME.postgres.database.azure.com:5432/$AZ_DATABASE_NAME
spring.r2dbc.username=nonspring
spring.r2dbc.password=$AZ_POSTGRESQL_NON_ADMIN_PASSWORD
spring.r2dbc.properties.sslMode=REQUIRE

Substitua as $AZ_DATABASE_SERVER_NAMEvariáveis , $AZ_DATABASE_NAMEe $AZ_POSTGRESQL_NON_ADMIN_PASSWORD pelos valores que você configurou no início deste artigo.

Aviso

Por razões de segurança, o Banco de Dados do Azure para PostgreSQL requer o uso de conexões SSL. É por isso que você precisa adicionar a propriedade de configuração spring.r2dbc.properties.sslMode=REQUIRE. Caso contrário, o driver PostgreSQL do R2DBC tentará se conectar usando uma conexão não segura, o que falhará.

Observação

Para obter um melhor desempenho, a propriedade spring.r2dbc.url está configurada para usar um pool de conexões usando r2dbc-pool.

Agora, você deverá conseguir iniciar seu aplicativo usando o wrapper do Maven fornecido da seguinte maneira:

./mvnw spring-boot:run

Aqui está uma captura de tela do aplicativo em execução pela primeira vez:

Criar o esquema de banco de dados

Dentro da classe principal DemoApplication, configure um novo bean do Spring que criará um esquema de banco de dados, usando o seguinte código:

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.r2dbc.connectionfactory.init.ConnectionFactoryInitializer;
import org.springframework.data.r2dbc.connectionfactory.init.ResourceDatabasePopulator;

import io.r2dbc.spi.ConnectionFactory;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Bean
    public ConnectionFactoryInitializer initializer(ConnectionFactory connectionFactory) {
        ConnectionFactoryInitializer initializer = new ConnectionFactoryInitializer();
        initializer.setConnectionFactory(connectionFactory);
        ResourceDatabasePopulator populator = new ResourceDatabasePopulator(new ClassPathResource("schema.sql"));
        initializer.setDatabasePopulator(populator);
        return initializer;
    }
}

Esse bean do Spring usa um arquivo chamado schema.sql; portanto, crie esse arquivo na pasta src/main/resources e adicione o seguinte texto:

DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);

Pare o aplicativo em execução e inicie-o novamente usando o comando a seguir. O aplicativo agora usará o banco de dados demo que você criou anteriormente e criará uma tabela todo dentro dele.

./mvnw spring-boot:run

Aqui está uma captura de tela da tabela do banco de dados enquanto está sendo criada:

Codificar o aplicativo

Em seguida, adicione o código Java que usará o R2DBC para armazenar e recuperar dados do servidor PostgreSQL.

Crie uma classe Java Todo ao lado da classe DemoApplication usando o seguinte código:

package com.example.demo;

import org.springframework.data.annotation.Id;

public class Todo {

    public Todo() {
    }

    public Todo(String description, String details, boolean done) {
        this.description = description;
        this.details = details;
        this.done = done;
    }

    @Id
    private Long id;

    private String description;

    private String details;

    private boolean done;

    public Long getId() {
        return id;
    }

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

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getDetails() {
        return details;
    }

    public void setDetails(String details) {
        this.details = details;
    }

    public boolean isDone() {
        return done;
    }

    public void setDone(boolean done) {
        this.done = done;
    }
}

Essa classe é um modelo de domínio mapeado na tabela de todo que você criou anteriormente.

Para gerenciar essa classe, você precisará de um repositório. Defina uma nova interface TodoRepository no mesmo pacote usando o seguinte código:

package com.example.demo;

import org.springframework.data.repository.reactive.ReactiveCrudRepository;

public interface TodoRepository extends ReactiveCrudRepository<Todo, Long> {
}

Esse repositório é um repositório reativo que o Spring Data R2DBC gerencia.

Conclua o aplicativo criando um controlador que pode armazenar e recuperar dados. Implemente uma classe TodoController no mesmo pacote e adicione o seguinte código:

package com.example.demo;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/")
public class TodoController {

    private final TodoRepository todoRepository;

    public TodoController(TodoRepository todoRepository) {
        this.todoRepository = todoRepository;
    }

    @PostMapping("/")
    @ResponseStatus(HttpStatus.CREATED)
    public Mono<Todo> createTodo(@RequestBody Todo todo) {
        return todoRepository.save(todo);
    }

    @GetMapping("/")
    public Flux<Todo> getTodos() {
        return todoRepository.findAll();
    }
}

Por fim, pare o aplicativo e inicie-o novamente usando o seguinte comando:

./mvnw spring-boot:run

Testar o aplicativo

Para testar o aplicativo, você pode usar cURL.

Primeiro, crie um item "todo" no banco de dados usando o seguinte comando:

curl --header "Content-Type: application/json" \
    --request POST \
    --data '{"description":"configuration","details":"congratulations, you have set up R2DBC correctly!","done": "true"}' \
    http://127.0.0.1:8080

Este comando deverá retornar o item criado, conforme mostrado aqui:

{"id":1,"description":"configuration","details":"congratulations, you have set up R2DBC correctly!","done":true}

Em seguida, recupere os dados usando uma nova solicitação do cURL com o seguinte comando:

curl http://127.0.0.1:8080

Esse comando retornará a lista de itens "todo", incluindo o item que você criou, conforme mostrado aqui:

[{"id":1,"description":"configuration","details":"congratulations, you have set up R2DBC correctly!","done":true}]

Aqui está uma captura de tela dessas solicitações cURL:

Parabéns! Você criou um aplicativo Spring Boot totalmente reativo que usa o R2DBC para armazenar e recuperar dados do Banco de Dados do Azure para PostgreSQL.

Limpar os recursos

Para limpar todos os recursos usados durante este início rápido, exclua o grupo de recursos usando o seguinte comando:

az group delete \
    --name $AZ_RESOURCE_GROUP \
    --yes

Próximas etapas

Para saber mais sobre como implantar um aplicativo Spring Data no Azure Spring Apps e usar a identidade gerenciada, consulte Tutorial: Implantar um aplicativo Spring no Azure Spring Apps com uma conexão sem senha com um banco de dados do Azure.

Para saber mais sobre o Spring e o Azure, continue no Spring no Centro de Documentação do Azure.

Spring no Azure

Confira também

Para obter mais informações sobre o Spring Data R2DBC, confira a documentação de referência do Spring.

Para obter mais informações sobre como usar o Azure com o Java, confira Azure para desenvolvedores Java e Trabalhar com o Azure DevOps e com o Java.

Compartilhar via

Usar o Spring Data R2DBC com o Banco de Dados do Azure para PostgreSQL

Pré-requisitos

Consulte o aplicativo de exemplo

Preparar o ambiente de trabalho

Criar uma instância do Banco de Dados do Azure para PostgreSQL e configurar o usuário administrador

Configurar um banco de dados PostgreSQL

Configurar uma regra de firewall para o servidor PostgreSQL

Criar um usuário não administrador do PostgreSQL e conceder permissão

Criar um aplicativo Spring Boot reativo

Gerar o aplicativo usando o Spring Initializr

Adicionar a implementação do driver PostgreSQL reativo

Configurar o Spring Boot para usar o Banco de Dados do Azure para PostgreSQL

Criar o esquema de banco de dados

Codificar o aplicativo

Testar o aplicativo

Limpar os recursos

Próximas etapas

Confira também

Comentários

Recursos adicionais