Avvio rapido: Usare Java e JDBC con il server flessibile di Database di Azure per PostgreSQL
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 altri servizi Microsoft in una posizione centrale, 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, tali credenziali verranno archiviate nella tabella user. Poiché queste password vengono archiviate in PostgreSQL, è necessario gestire manualmente la rotazione delle password.
Prerequisiti
- Un account Azure. Se non è disponibile, ottenere una versione di valutazione gratuita.
- Azure Cloud Shell o interfaccia della riga di comando di Azure. È consigliabile usare Azure Cloud Shell in modo che l'accesso venga eseguito automaticamente e che sia possibile accedere a tutti gli strumenti necessari.
- Un'istanza supportata di Java Development Kit, versione 8 (inclusa in Azure Cloud Shell).
- Strumento di compilazione di Apache Maven.
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 usareeastusper impostazione predefinita, ma è consigliabile configurare un'area più vicina a dove si risiede. Per visualizzare l'elenco completo di aree disponibili, immettereaz 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>: 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.
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();
}
}
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
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per