Avvio rapido: usare Java e JDBC con Database di Azure per PostgreSQL - Server flessibile

Questo articolo illustra come creare un'applicazione di esempio che usa Java e JDBC per archiviare e recuperare informazioni in Database di Azure per PostgreSQL.

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

Questo articolo include 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 di Microsoft Entra, è possibile gestire le identità utente del database e altri servizi Microsoft da un'unica posizione centrale, semplificando la gestione delle autorizzazioni.

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

Prerequisiti

Preparare l'ambiente di lavoro

Innanzitutto, usare il comando seguente per impostare alcune variabili di ambiente.

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, usati in questo articolo:

  • <YOUR_DATABASE_SERVER_NAME>: Il nome del tuo Database di Azure per PostgreSQL flexible server, che deve essere univoco in Azure.
  • <YOUR_DATABASE_NAME>: nome del database del server flessibile Database di Azure per PostgreSQL, che deve essere univoco all'interno di Azure.
  • <YOUR_AZURE_REGION>: area di Azure da usare. È possibile usare eastus per impostazione predefinita, ma scegliere un'area più vicina alla posizione in cui si vive. Per visualizzare l'elenco completo delle aree disponibili, immettere az account list-locations.
  • <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>: nome utente per il server flessibile Database di Azure per PostgreSQL. Verificare che il nome utente sia un utente valido nel tenant Microsoft Entra.
  • <YOUR_LOCAL_IP_ADDRESS>: indirizzo IP del computer locale da cui si esegue l'applicazione Spring Boot. Un modo pratico per trovare è aprire whatismyip.akamai.com.

Importante

Quando si imposta <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>, l'utente deve esistere già nel tenant Microsoft Entra oppure non è possibile creare un utente 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 server flessibile

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

Creare un server flessibile e configurare l'utente amministratore

Annotazioni

Per informazioni più dettagliate sulla creazione di server flessibili Database di Azure per PostgreSQL, vedere Avvio rapido: Creare un server flessibile Database di Azure per PostgreSQL.

Se si usa 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 in Database di Azure per PostgreSQL.

Importante

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

Problemi? Segnalaceli.

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

I server flessibili di Database di Azure per PostgreSQL sono sicuri per impostazione predefinita. Hanno un firewall che blocca tutte le connessioni in ingresso. Per usare il database, aggiungere una regola del firewall che concede all'indirizzo IP locale l'accesso 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 connette al server flessibile 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 che segue il termine nameservere 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 il comando seguente per aprire il firewall del server nell'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 di Azure Database 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 nel Database di Azure per PostgreSQL e concedere l'autorizzazione

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

Annotazioni

Per informazioni più dettagliate sulla gestione degli utenti Database di Azure per PostgreSQL, vedere Gestire i ruoli Microsoft Entra in Database di Azure per PostgreSQL.

Creare uno script SQL denominato create_ad_user.sql per la creazione di un utente non amministratore. Aggiungi i contenuti seguenti e salvali localmente:

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

Usare quindi il comando seguente per eseguire lo script SQL e creare il Microsoft Entra utente non amministratore:

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

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. Aggiungi un file pom.xml nella directory radice con il seguente contenuto:

<?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.7.5</version>
      </dependency>
      <dependency>
        <groupId>com.azure</groupId>
        <artifactId>azure-identity-extensions</artifactId>
        <version>1.2.0</version>
      </dependency>
    </dependencies>
</project>

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

  • Java 8
  • Un driver di PostgreSQL recente per Java

Preparare un file di configurazione per connettersi a Database di Azure per PostgreSQL

Creare un file src/main/resources/application.properties e 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

Annotazioni

La proprietà url di configurazione include ?sslmode=require per assicurarsi che il driver JDBC usi TLS (Transport Layer Security) durante la connessione al database. L'uso di TLS è obbligatorio con Database di Azure per PostgreSQL server flessibili ed è una procedura consigliata per la sicurezza.

Creare un file SQL per generare lo schema del database

Usare un file src/main/resources/schema.sql per creare uno schema di database. Creare il file e aggiungere 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

Le sezioni seguenti illustrano la scrittura del codice Java che si connette al database, definisce un modello di dati ed esegue operazioni CRUD di base.

Stabilire la connessione al database

Aggiungere quindi il codice Java che usa JDBC per archiviare e recuperare dati dal server flessibile 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? Segnalaceli.

Questo codice Java usa i file application.properties e schema.sql che hai creato in precedenza per connettersi al server flessibile di Database di Azure per PostgreSQL e creare uno schema in cui archiviare i dati.

In questo file i metodi per inserire, leggere, aggiornare ed eliminare i dati vengono commentati. Il resto di questo articolo illustra la codifica di questi metodi ed è possibile rimuovere il commento uno dopo l'altro.

Annotazioni

Le credenziali del database sono archiviate nelle proprietà user e password del file application.properties. Il codice usa tali credenziali 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, è 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 si connette al server flessibile Database di Azure per PostgreSQL, crea uno schema di database e quindi chiude la connessione, come illustrato 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 Todo classe Java accanto alla DemoApplication classe 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 todo tabella creata durante l'esecuzione dello script schema.sql .

Inserire dati in 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);

Quando si esegue la classe principale, deve produrre 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

Leggi i dati da Database di Azure per PostgreSQL

Per verificare che il codice funzioni correttamente, leggere i dati inseriti in precedenza.

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

Quando si esegue la classe principale, deve produrre 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

Aggiornare i dati in Database di Azure per PostgreSQL

Per aggiornare i dati, seguire questa procedura.

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

Quando si esegue la classe principale, deve produrre 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

Eliminare i dati in Database di Azure per PostgreSQL

Infine, eliminare 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);

Quando si esegue la classe principale, deve produrre 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

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

Per pulire tutte le risorse usate durante questa guida introduttiva, eliminare il gruppo di risorse usando il comando seguente:

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

Contenuti correlati

  • Last updated on