Condividi tramite

Avvio rapido: Usare Java e JDBC con il server flessibile di Database di Azure per PostgreSQL

  • Articolo

SI APPLICA A: Server flessibile di Database di Azure per PostgreSQL

Questo articolo illustra la creazione di un'applicazione di esempio che usa Java e JDBC per archiviare e recuperare informazioni nel server flessibile di Database di Azure per PostgreSQL.

JDBC è l'API Java standard per la connessione ai database relazionali tradizionali.

In questo articolo verranno inclusi due metodi di autenticazione: autenticazione Microsoft Entra e autenticazione PostgreSQL. La scheda Senza password mostra l'autenticazione Microsoft Entra, la scheda Password l'autenticazione PostgreSQL.

L'autenticazione Microsoft Entra è un meccanismo per connettersi a Database di Azure per PostgreSQL tramite identità definite in Microsoft Entra ID. Con l'autenticazione Microsoft Entra è possibile gestire centralmente le identità degli utenti del database e di altri servizi Microsoft semplificando la gestione delle autorizzazioni.

L'autenticazione PostgreSQL usa gli account archiviati in PostgreSQL. Se si sceglie di usare password come credenziali per gli account, queste credenziali verranno archiviate nella tabella user. Poiché queste password vengono archiviate in PostgreSQL, è necessario gestire manualmente la rotazione delle password.

Prerequisiti

Preparare l'ambiente di lavoro

Prima, configurare alcune variabili di ambiente usando il comando seguente.

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_AD_NON_ADMIN_USERNAME=<YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>
export AZ_LOCAL_IP_ADDRESS=<YOUR_LOCAL_IP_ADDRESS>
export CURRENT_USERNAME=$(az ad signed-in-user show --query userPrincipalName -o tsv)

Sostituire i segnaposto con i valori seguenti, che vengono usati nell'intero articolo:

  • <YOUR_DATABASE_SERVER_NAME>: nome dell'istanza del server flessibile di Database di Azure per PostgreSQL, che deve essere univoco in Azure.
  • <YOUR_DATABASE_NAME>: nome del database dell'istanza del server flessibile di Database di Azure per PostgreSQL, che deve essere univoco in Azure.
  • <YOUR_AZURE_REGION>: area di Azure da usare. È possibile usare eastus per impostazione predefinita, ma è consigliabile configurare un'area più vicina a dove si risiede. Per visualizzare l'elenco completo di aree disponibili, immettere az account list-locations.
  • <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>: nome utente dell'istanza del server flessibile di Database di Azure per PostgreSQL. Assicurarsi che il nome utente sia un utente valido nel tenant di Microsoft Entra.
  • <YOUR_LOCAL_IP_ADDRESS>: l'indirizzo IP del computer locale, da cui verrà eseguita l'applicazione Spring Boot. Un modo pratico per trovarlo è aprire whatismyip.akamai.com.

Importante

Quando si imposta <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>, il nome utente deve esistere già nel tenant di Microsoft Entra, altrimenti non sarà possibile creare un utente di Microsoft Entra nel database.

Creare quindi un gruppo di risorse usando il comando seguente:

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

Creare un'istanza del server flessibile di Database di Azure per PostgreSQL

Le sezioni seguenti descrivono come creare e configurare l'istanza del database.

Creare un'istanza del server flessibile di Database di Azure per PostgreSQL e configurare l'utente amministratore

La prima cosa che si crea è un'istanza del server flessibile di Database di Azure per PostgreSQL gestita.

Nota

Per altre informazioni dettagliate sulla creazione di istanze del server flessibile di Database di Azure per PostgreSQL, vedere Creare un'istanza del server flessibile di Database di Azure per PostgreSQL usando il portale di Azure.

Se è in uso l'interfaccia della riga di comando di Azure, eseguire il comando seguente per assicurarsi che disponga di autorizzazioni sufficienti:

az login --scope https://graph.microsoft.com/.default

Eseguire il comando seguente per creare il server:

az postgres flexible-server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME \
    --location $AZ_LOCATION \
    --yes \
    --output tsv

Per configurare un amministratore di Microsoft Entra dopo aver creato il server, seguire la procedura descritta in Gestire i ruoli di Microsoft Entra nel server flessibile di Database di Azure per PostgreSQL.

Importante

Quando si configura un amministratore, viene aggiunto un nuovo utente con privilegi di amministratore completi al database di Azure dell'istanza del server flessibile di Database di Azure per PostgreSQL. È possibile creare più amministratori di Microsoft Entra per istanza del server flessibile di Database di Azure per PostgreSQL.

Problemi? Segnalarli.

Configurare una regola del firewall per l'istanza del server flessibile di Database di Azure per PostgreSQL

Le istanze del server flessibile di Database di Azure per PostgreSQL sono protette per impostazione predefinita. Includono un firewall che non consente alcuna connessione in ingresso. Per poter usare il database, è necessario aggiungere una regola del firewall che consenta all'indirizzo IP locale di accedere al server di database.

Poiché all'inizio di questo articolo è stato configurato un indirizzo IP locale, è possibile aprire il firewall del server eseguendo questo 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 ci si sa connettendo all'istanza del server flessibile di Database di Azure per PostgreSQL da Sottosistema Windows per Linux (WSL) in un computer Windows, è necessario aggiungere l'ID host WSL al firewall.

Ottenere l'indirizzo IP del computer host eseguendo il comando seguente in WSL:

cat /etc/resolv.conf

Copiare l'indirizzo IP seguendo il termine nameserver, quindi usare il comando seguente per impostare una variabile di ambiente per l'indirizzo IP WSL:

AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

Usare quindi il comando seguente per aprire il firewall del server all'app basata su 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

Configurare un database del server flessibile di Database di Azure per PostgreSQL

Creare un nuovo database usando il comando seguente:

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

Creare un utente non amministratore del server flessibile di Database di Azure per PostgreSQL e concedere l'autorizzazione

Creare quindi un utente non amministratore e concedergli tutte le autorizzazioni al database.

Nota

Per altre informazioni dettagliate sulla gestione degli utenti dei server flessibili di Database di Azure per PostgreSQL, vedere Gestire gli utenti di Microsoft Entra- Server flessibile di Database di Azure per PostgreSQL.

Creare uno script SQL denominato create_ad_user.sql per la creazione di un utente non amministratore. Aggiungervi il contenuto seguente e salvarlo in locale:

cat << EOF > create_ad_user.sql
select * from pgaadauth_create_principal('$AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME', false, false);
EOF

Quindi, usare il comando seguente per eseguire lo script SQL per creare l'utente non amministratore di Microsoft Entra:

psql "host=$AZ_DATABASE_SERVER_NAME.postgres.database.azure.com user=$CURRENT_USERNAME dbname=postgres port=5432 password=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken) sslmode=require" < create_ad_user.sql

A questo punto, usare il comando seguente per rimuovere il file di script SQL temporaneo:

rm create_ad_user.sql

Creare un nuovo progetto Java

Usando l'IDE preferito, creare un nuovo progetto Java usando Java 8 o versione successiva e aggiungere un file pom.xml nella directory radice con il contenuto seguente:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>

    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
      <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.3.6</version>
      </dependency>
      <dependency>
        <groupId>com.azure</groupId>
        <artifactId>azure-identity-extensions</artifactId>
        <version>1.0.0</version>
      </dependency>
    </dependencies>
</project>

Questo file è Apache Maven che configura il progetto da usare:

  • Java 8
  • Un driver di PostgreSQL recente per Java

Preparare un file di configurazione per la connessione al server flessibile di Database di Azure per PostgreSQL

Creare un file src/main/resources/application.properties, quindi aggiungere il contenuto seguente:

cat << EOF > src/main/resources/application.properties
url=jdbc:postgresql://${AZ_DATABASE_SERVER_NAME}.postgres.database.azure.com:5432/${AZ_DATABASE_NAME}?sslmode=require&authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin
user=${AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME}
EOF

Nota

Alla proprietà di configurazione url è aggiunto?serverTimezone=UTC per indicare al driver JDBC di usare TLS (Transport Layer Security) per la connessione al database. L'uso di TLS con il server flessibile di Database di Azure per PostgreSQL è obbligatorio ed è una procedura consigliata per la sicurezza.

Creare un file SQL per generare lo schema del database

Per creare uno schema del database, verrà usato un file src/main/resources/schema.sql. Creare tale file con il contenuto seguente:

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

Codice dell'applicazione

Stabilire la connessione al database

Aggiungere quindi il codice Java che userà JDBC per archiviare e recuperare dati dall'istanza del server flessibile di Database di Azure per PostgreSQL.

Creare un file src/main/java/DemoApplication.java e aggiungere il contenuto seguente:

package com.example.demo;

import java.sql.*;
import java.util.*;
import java.util.logging.Logger;

public class DemoApplication {

    private static final Logger log;

    static {
        System.setProperty("java.util.logging.SimpleFormatter.format", "[%4$-7s] %5$s %n");
        log =Logger.getLogger(DemoApplication.class.getName());
    }

    public static void main(String[] args) throws Exception {
        log.info("Loading application properties");
        Properties properties = new Properties();
        properties.load(DemoApplication.class.getClassLoader().getResourceAsStream("application.properties"));

        log.info("Connecting to the database");
        Connection connection = DriverManager.getConnection(properties.getProperty("url"), properties);
        log.info("Database connection test: " + connection.getCatalog());

        log.info("Create database schema");
        Scanner scanner = new Scanner(DemoApplication.class.getClassLoader().getResourceAsStream("schema.sql"));
        Statement statement = connection.createStatement();
        while (scanner.hasNextLine()) {
            statement.execute(scanner.nextLine());
        }

		/*
		Todo todo = new Todo(1L, "configuration", "congratulations, you have set up JDBC correctly!", true);
        insertData(todo, connection);
        todo = readData(connection);
        todo.setDetails("congratulations, you have updated data!");
        updateData(todo, connection);
        deleteData(todo, connection);
		*/

        log.info("Closing database connection");
        connection.close();
    }
}

Problemi? Segnalarli.

Questo codice Java userà i file application.properties e schema.sql creati in precedenza per stabilire una connessione con l'istanza del server flessibile di Database di Azure per PostgreSQL e creare uno schema in cui archiviare i dati.

In questo file è possibile notare che i metodi di inserimento, lettura, aggiornamento ed eliminazione dei dati sono stati commentati. Il codice di tali metodi verranno scritti nella parte restante di questo articolo e sarà possibile rimuovere i commenti uno dopo l'altro.

Nota

Le credenziali del database sono archiviate nelle proprietà user e password del file application.properties. Queste credenziali vengono usate durante l'esecuzione di DriverManager.getConnection(properties.getProperty("url"), properties);, perché il file delle proprietà viene passato come argomento.

È ora possibile eseguire questa classe main con lo strumento preferito:

  • Usando l'IDE, dovrebbe essere possibile fare clic con il pulsante destro del mouse sulla classe DemoApplication ed eseguirla.
  • Con Maven è possibile eseguire l'applicazione eseguendo: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".

L'applicazione dovrà connettersi all'istanza del server flessibile di Database di Azure per PostgreSQL, creare uno schema del database e quindi chiudere la connessione, come si vedrà nei log della console:

[INFO   ] Loading application properties
[INFO   ] Connecting to the database
[INFO   ] Database connection test: demo
[INFO   ] Create database schema
[INFO   ] Closing database connection

Creare una classe di dominio

Creare una nuova classe Java Todo accanto alla classe DemoApplication e aggiungere il codice seguente:

package com.example.demo;

public class Todo {

    private Long id;
    private String description;
    private String details;
    private boolean done;

    public Todo() {
    }

    public Todo(Long id, String description, String details, boolean done) {
        this.id = id;
        this.description = description;
        this.details = details;
        this.done = 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;
    }

    @Override
    public String toString() {
        return "Todo{" +
                "id=" + id +
                ", description='" + description + '\'' +
                ", details='" + details + '\'' +
                ", done=" + done +
                '}';
    }
}

Questa classe è un modello di dominio mappato alla tabella todo creata durante l'esecuzione dello script schema.sql.

Inserire dati nel server flessibile di Database di Azure per PostgreSQL

Nel file src/main/java/DemoApplication.java aggiungere il metodo seguente dopo il metodo main per inserire i dati nel database:

private static void insertData(Todo todo, Connection connection) throws SQLException {
    log.info("Insert data");
    PreparedStatement insertStatement = connection
            .prepareStatement("INSERT INTO todo (id, description, details, done) VALUES (?, ?, ?, ?);");

    insertStatement.setLong(1, todo.getId());
    insertStatement.setString(2, todo.getDescription());
    insertStatement.setString(3, todo.getDetails());
    insertStatement.setBoolean(4, todo.isDone());
    insertStatement.executeUpdate();
}

È ora possibile rimuovere il commento dalle due righe seguenti nel metodo main:

Todo todo = new Todo(1L, "configuration", "congratulations, you have set up JDBC correctly!", true);
insertData(todo, connection);

Se si esegue la classe main, si dovrebbe ottenere l'output seguente:

[INFO   ] Loading application properties
[INFO   ] Connecting to the database
[INFO   ] Database connection test: demo
[INFO   ] Create database schema
[INFO   ] Insert data
[INFO   ] Closing database connection

Lettura dei dati dal server flessibile di Database di Azure per PostgreSQL

A questo punto verranno letti i dati inseriti in precedenza per verificare il corretto funzionamento del codice.

Nel file src/main/java/DemoApplication.java aggiungere il metodo seguente dopo il metodo insertData per leggere i dati dal database:

private static Todo readData(Connection connection) throws SQLException {
    log.info("Read data");
    PreparedStatement readStatement = connection.prepareStatement("SELECT * FROM todo;");
    ResultSet resultSet = readStatement.executeQuery();
    if (!resultSet.next()) {
        log.info("There is no data in the database!");
        return null;
    }
    Todo todo = new Todo();
    todo.setId(resultSet.getLong("id"));
    todo.setDescription(resultSet.getString("description"));
    todo.setDetails(resultSet.getString("details"));
    todo.setDone(resultSet.getBoolean("done"));
    log.info("Data read from the database: " + todo.toString());
    return todo;
}

È ora possibile rimuovere il commento dalla riga seguente nel metodo main:

todo = readData(connection);

Se si esegue la classe main, si dovrebbe ottenere l'output seguente:

[INFO   ] Loading application properties
[INFO   ] Connecting to the database
[INFO   ] Database connection test: demo
[INFO   ] Create database schema
[INFO   ] Insert data
[INFO   ] Read data
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have set up JDBC correctly!', done=true}
[INFO   ] Closing database connection

Aggiornamento dei dati nel server flessibile di Database di Azure per PostgreSQL

A questo punto, verranno aggiornati i dati inseriti in precedenza.

Sempre nel file src/main/java/DemoApplication.java aggiungere il metodo seguente dopo il metodo readData per aggiornare i dati all'interno del database:

private static void updateData(Todo todo, Connection connection) throws SQLException {
    log.info("Update data");
    PreparedStatement updateStatement = connection
            .prepareStatement("UPDATE todo SET description = ?, details = ?, done = ? WHERE id = ?;");

    updateStatement.setString(1, todo.getDescription());
    updateStatement.setString(2, todo.getDetails());
    updateStatement.setBoolean(3, todo.isDone());
    updateStatement.setLong(4, todo.getId());
    updateStatement.executeUpdate();
    readData(connection);
}

È ora possibile rimuovere il commento dalle due righe seguenti nel metodo main:

todo.setDetails("congratulations, you have updated data!");
updateData(todo, connection);

Se si esegue la classe main, si dovrebbe ottenere l'output seguente:

[INFO   ] Loading application properties
[INFO   ] Connecting to the database
[INFO   ] Database connection test: demo
[INFO   ] Create database schema
[INFO   ] Insert data
[INFO   ] Read data
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have set up JDBC correctly!', done=true}
[INFO   ] Update data
[INFO   ] Read data
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have updated data!', done=true}
[INFO   ] Closing database connection

Eliminazione dei dati nel server flessibile di Database di Azure per PostgreSQL

A questo punto, verranno eliminati i dati inseriti in precedenza.

Sempre nel file src/main/java/DemoApplication.java aggiungere il metodo seguente dopo il metodo updateData per eliminare i dati all'interno del database:

private static void deleteData(Todo todo, Connection connection) throws SQLException {
    log.info("Delete data");
    PreparedStatement deleteStatement = connection.prepareStatement("DELETE FROM todo WHERE id = ?;");
    deleteStatement.setLong(1, todo.getId());
    deleteStatement.executeUpdate();
    readData(connection);
}

È ora possibile rimuovere il commento dalla riga seguente nel metodo main:

deleteData(todo, connection);

Se si esegue la classe main, si dovrebbe ottenere l'output seguente:

[INFO   ] Loading application properties
[INFO   ] Connecting to the database
[INFO   ] Database connection test: demo
[INFO   ] Create database schema
[INFO   ] Insert data
[INFO   ] Read data
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have set up JDBC correctly!', done=true}
[INFO   ] Update data
[INFO   ] Read data
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have updated data!', done=true}
[INFO   ] Delete data
[INFO   ] Read data
[INFO   ] There is no data in the database!
[INFO   ] Closing database connection

Pulire le risorse

Complimenti. È stata creata un'applicazione Java che usa JDBC per archiviare e recuperare i dati dal server flessibile di Database di Azure per PostgreSQL.

Per pulire tutte le risorse usate in questo argomento di avvio rapido, eliminare il gruppo di risorse con il comando seguente:

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

Passaggi successivi

Eseguire la migrazione del database usando le funzionalità di esportazione e importazione