Použití Spring Data R2DBC se službou Azure Database for PostgreSQL

Článek
10/23/2023

Tento článek ukazuje vytvoření ukázkové aplikace, která používá Spring Data R2DBC k ukládání a načítání informací v databázi Azure Database for PostgreSQL . Ukázka použije implementaci R2DBC pro PostgreSQL z úložiště r2dbc-postgresql na GitHubu.

R2DBC přináší reaktivní rozhraní API do tradičních relačních databází. Pomocí aplikace Spring WebFlux můžete vytvářet plně reaktivní aplikace Spring Boot, které používají neblokující rozhraní API. Poskytuje lepší škálovatelnost než klasický přístup "jeden vlákno na připojení".

Požadavky

Předplatné Azure – vytvořte si ho zdarma.
Java Development Kit (JDK) verze 8 nebo vyšší.
Apache Maven
Rozhraní příkazového řádku Azure.

Klient příkazového řádku PostgreSQL.
cURL nebo podobný nástroj HTTP pro testování funkčnosti.

Zobrazení ukázkové aplikace

V tomto článku naprogramujete ukázkovou aplikaci. Pokud chcete přejít rychleji, tato aplikace je již kódována a k dispozici na adrese https://github.com/Azure-Samples/quickstart-spring-data-r2dbc-postgresql.

Příprava pracovního prostředí

Nejprve nastavte některé proměnné prostředí spuštěním následujících příkazů:

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>

Zástupné symboly nahraďte následujícími hodnotami, které se používají v tomto článku:

<YOUR_DATABASE_SERVER_NAME>: Název vašeho serveru PostgreSQL, který by měl být jedinečný v rámci Azure.
<YOUR_DATABASE_NAME>: Název databáze serveru PostgreSQL, který by měl být jedinečný v rámci Azure.
<YOUR_AZURE_REGION>: Oblast Azure, kterou použijete. Standardně můžete použít eastus, ale doporučujeme nakonfigurovat oblast blíže k místu, kde se nacházíte. Úplný seznam dostupných oblastí můžete zobrazit pomocí .az account list-locations
<YOUR_POSTGRESQL_ADMIN_PASSWORD> a <YOUR_POSTGRESQL_NON_ADMIN_PASSWORD>: Heslo vašeho databázového serveru PostgreSQL, které by mělo mít minimálně osm znaků. Znaky by měly být ze tří z následujících kategorií: velká písmena anglické abecedy, malá písmena anglické abecedy, číslice (0–9) a jiné než alfanumerické znaky (!, $, #, %atd.).
<YOUR_LOCAL_IP_ADDRESS>: IP adresa místního počítače, ze kterého spustíte aplikaci Spring Boot. Jedním z pohodlných způsobů, jak ji najít, je otevřít whatismyip.akamai.com.

Dále pomocí následujícího příkazu vytvořte skupinu prostředků:

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

Vytvoření instance Azure Database for PostgreSQL a nastavení uživatele správce

První věc, kterou vytvoříte, je spravovaný server PostgreSQL s uživatelem správce.

Poznámka:

Podrobnější informace o vytváření serverů PostgreSQL najdete v tématu Vytvoření serveru Azure Database for PostgreSQL pomocí webu Azure Portal.

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

Konfigurace databáze PostgreSQL

Server PostgreSQL, který jste vytvořili dříve, je prázdný. K vytvoření nové databáze použijte následující příkaz.

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

Konfigurace pravidla brány firewall pro server PostgreSQL

Instance Azure Database for PostgreSQL jsou ve výchozím nastavení zabezpečené. Obsahuje bránu firewall, která nepovoluje žádné příchozí připojení. Abyste mohli databázi používat, musíte přidat pravidlo brány firewall, které umožní přístup k databázovému serveru místní IP adresou.

Vzhledem k tomu, že jste na začátku tohoto článku nakonfigurovali místní IP adresu, můžete bránu firewall serveru otevřít spuštěním následujícího příkazu:

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

Pokud se připojujete k serveru PostgreSQL z Subsystém Windows pro Linux (WSL) na počítači s Windows, musíte do brány firewall přidat ID hostitele WSL.

Získejte IP adresu hostitelského počítače spuštěním následujícího příkazu ve WSL:

cat /etc/resolv.conf

Zkopírujte IP adresu za termínem nameservera pak pomocí následujícího příkazu nastavte proměnnou prostředí pro IP adresu WSL:

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

Pak pomocí následujícího příkazu otevřete bránu firewall serveru pro vaši aplikaci založenou na 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

Vytvoření uživatele PostgreSQL bez oprávnění správce a udělení oprávnění

Dále vytvořte uživatele bez oprávnění správce a udělte mu všechna oprávnění.

Poznámka:

Podrobnější informace o vytváření uživatelů PostgreSQL najdete v tématu Vytváření uživatelů ve službě Azure Database for PostgreSQL.

Vytvořte skript SQL s názvem create_user.sql pro vytvoření uživatele bez oprávnění správce. Přidejte následující obsah a uložte ho místně:

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

Potom pomocí následujícího příkazu spusťte skript SQL a vytvořte uživatele Microsoft Entra bez oprávnění správce:

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

Teď pomocí následujícího příkazu odeberte dočasný soubor skriptu SQL:

rm create_user.sql

Vytvoření reaktivní aplikace Spring Boot

K vytvoření reaktivní aplikace Spring Boot použijeme Spring Initializr. Aplikace, kterou vytvoříme, používá:

Spring Boot 2.7.11.
Následující závislosti: Spring Reactive Web (označovaný také jako Spring WebFlux) a Spring Data R2DBC.

Vygenerování aplikace pomocí Spring Initializr

Pomocí následujícího příkazu vygenerujte aplikaci na příkazovém řádku:

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 -

Přidání reaktivní implementace ovladače PostgreSQL

Otevřete soubor pom.xml vygenerovaného projektu a pak přidejte reaktivní ovladač PostgreSQL z úložiště r2dbc-postgresql na GitHubu. spring-boot-starter-webflux Za závislost přidejte následující text:

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

Konfigurace Spring Bootu pro použití Služby Azure Database for PostgreSQL

Otevřete soubor src/main/resources/application.properties a přidejte následující text:

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

$AZ_DATABASE_SERVER_NAMENahraďte hodnoty , $AZ_DATABASE_NAMEa $AZ_POSTGRESQL_NON_ADMIN_PASSWORD proměnné hodnotami, které jste nakonfigurovali na začátku tohoto článku.

Upozorňující

Z bezpečnostních důvodů vyžaduje Azure Database for PostgreSQL použití připojení SSL. Proto je potřeba přidat spring.r2dbc.properties.sslMode=REQUIRE vlastnost konfigurace, jinak se ovladač R2DBC PostgreSQL pokusí připojit pomocí nezabezpečeného připojení, což selže.

Poznámka:

Kvůli lepšímu výkonu spring.r2dbc.url je vlastnost nakonfigurovaná tak, aby používala fond připojení pomocí fondu r2dbc-pool.

Teď byste měli být schopni spustit aplikaci pomocí poskytnuté obálky Maven následujícím způsobem:

./mvnw spring-boot:run

Zde je obrázek poprvé spuštěné aplikace:

Vytvoření schématu databáze

V hlavní DemoApplication třídě nakonfigurujte novou sadu Spring bean, která vytvoří schéma databáze pomocí následujícího kódu:

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

Tato aplikace Spring bean používá soubor s názvem schema.sql, takže ho vytvořte ve složce src/main/resources a přidejte následující text:

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

Zastavte spuštěnou aplikaci a spusťte ji znovu pomocí následujícího příkazu. Aplikace teď bude používat databázi demo, kterou jste vytvořili dřív, a vytvoří v ní tabulku todo.

./mvnw spring-boot:run

Tady je snímek obrazovky s tabulkou databáze při vytváření:

Vytvoření kódu aplikace

Dále přidejte kód Java, který bude používat R2DBC k ukládání a načítání dat ze serveru PostgreSQL.

Vytvořte novou Todo třídu Java vedle DemoApplication třídy pomocí následujícího kódu:

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

Tato třída je doménový model mapovaný na tabulku todo, kterou jste vytvořili dřív.

Ke správě této třídy budete potřebovat úložiště. Pomocí následujícího kódu definujte nové TodoRepository rozhraní ve stejném balíčku:

package com.example.demo;

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

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

Toto úložiště je reaktivní úložiště, které spravuje Spring Data R2DBC.

Dokončete aplikaci vytvořením kontroleru, který může ukládat a načítat data. Ve stejném balíčku implementujte třídu TodoController a přidejte následující kód:

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

Nakonec aplikaci zastavte a znovu ji spusťte pomocí následujícího příkazu:

./mvnw spring-boot:run

Testování aplikace

K otestování aplikace můžete použít cURL.

Nejprve pomocí následujícího příkazu vytvořte v databázi novou položku „úkolu“:

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

Tento příkaz by měl vrátit vytvořenou položku, jak je znázorněno tady:

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

Potom načtěte data pomocí nového požadavku cURL pomocí následujícího příkazu:

curl http://127.0.0.1:8080

Tento příkaz vrátí seznam položek "todo", včetně položky, kterou jste vytvořili, jak je znázorněno tady:

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

Tady je snímek obrazovky s těmito požadavky cURL:

Blahopřejeme! Vytvořili jste plně reaktivní aplikaci Spring Boot, která k ukládání a načítání dat ze služby Azure Database for PostgreSQL používá R2DBC.

Vyčištění prostředků

Pokud chcete vyčistit všechny prostředky použité během tohoto rychlého startu, odstraňte skupinu prostředků pomocí následujícího příkazu:

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

Další kroky

Další informace o nasazení aplikace Spring Data do Azure Spring Apps a použití spravované identity najdete v tématu Kurz: Nasazení aplikace Spring do Azure Spring Apps s bez heslem připojení k databázi Azure.

Pokud se chcete dozvědět více o architektuře Spring a Azure, přejděte do centra dokumentace Spring v Azure.

Spring v Azure

Viz také

Další informace o Spring Data R2DBC najdete v referenční dokumentaci spring.

Další informace o používání Azure s jazykem Java najdete v článku Azure pro vývojáře v jazyce Java a Práce s Azure DevOps a jazykem Java.

Sdílet prostřednictvím

Použití Spring Data R2DBC se službou Azure Database for PostgreSQL

Požadavky

Zobrazení ukázkové aplikace

Příprava pracovního prostředí

Vytvoření instance Azure Database for PostgreSQL a nastavení uživatele správce

Konfigurace databáze PostgreSQL

Konfigurace pravidla brány firewall pro server PostgreSQL

Vytvoření uživatele PostgreSQL bez oprávnění správce a udělení oprávnění

Vytvoření reaktivní aplikace Spring Boot

Vygenerování aplikace pomocí Spring Initializr

Přidání reaktivní implementace ovladače PostgreSQL

Konfigurace Spring Bootu pro použití Služby Azure Database for PostgreSQL

Vytvoření schématu databáze

Vytvoření kódu aplikace

Testování aplikace

Vyčištění prostředků

Další kroky

Viz také

Váš názor

Další materiály