Usare Spring Data JDBC con Azure Database for PostgreSQL

Questa esercitazione illustra come archiviare i dati in un database Azure Database for PostgreSQL usando Spring Data JDBC.

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

In questa esercitazione sono inclusi due metodi di autenticazione: l'autenticazione di Microsoft Entra e l'autenticazione di PostgreSQL. La scheda Passwordless mostra l'autenticazione Microsoft Entra e la scheda Password mostra l'autenticazione PostgreSQL.

Microsoft Entra l'autenticazione è un meccanismo per connettersi a Azure Database for PostgreSQL usando le identità definite in Microsoft Entra ID. Con l'autenticazione Microsoft Entra, è possibile gestire le identità utente 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, queste credenziali verranno archiviate nella tabella user. Poiché queste password vengono archiviate in PostgreSQL, è necessario gestire manualmente la rotazione delle password.

Prerequisiti

• Una sottoscrizione Azure - crearne una gratuitamente.

• Java Development Kit (JDK) versione 8 o successiva.

• Apache Maven.

• Interfaccia della riga di comando di Azure.

• Client della riga di comando di PostgreSQL.

• Se non si ha un'applicazione Spring Boot, creare un progetto Maven con Spring Initializr. Assicurarsi di selezionare Maven Project e, in Dependencies aggiungere il Spring Web, Spring Data JDBC e PostgreSQL Driver e quindi selezionare Java versione 8 o successiva.

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

psql "host=postgresqlflexibletest.postgres.database.azure.com user=<your_postgresql_ad_admin_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

cat << EOF > create_user.sql
CREATE ROLE "<your_postgresql_non_admin_username>" WITH LOGIN PASSWORD '<your_postgresql_non_admin_password>';
GRANT ALL PRIVILEGES ON DATABASE demo TO "<your_postgresql_non_admin_username>";
EOF

psql "host=postgresqlflexibletest.postgres.database.azure.com user=<your_postgresql_admin_username> dbname=demo port=5432 password=<your_postgresql_admin_password> sslmode=require" < create_user.sql

cat << EOF > create_ad_user.sql
SET aad_validate_oids_in_tenant = off;
CREATE ROLE "<your_postgresql_ad_non_admin_username>" WITH LOGIN IN ROLE azure_ad_user;
GRANT ALL PRIVILEGES ON DATABASE demo TO "<your_postgresql_ad_non_admin_username>";
EOF

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

cat << EOF > create_user.sql
CREATE ROLE "<your_postgresql_non_admin_username>" WITH LOGIN PASSWORD '<your_postgresql_non_admin_password>';
GRANT ALL PRIVILEGES ON DATABASE demo TO "<your_postgresql_non_admin_username>";
EOF

psql "host=postgresqlsingletest.postgres.database.azure.com user=<your_postgresql_admin_username>@postgresqlsingletest dbname=demo port=5432 password=<your_postgresql_admin_password> sslmode=require" < create_user.sql

2. Creare il file di configurazione src/main/resources/schema.sql per configurare lo schema del database, quindi aggiungere il contenuto seguente.

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

3. Creare una nuova classe Todo Java. Questa classe è un modello di dominio mappato alla todo tabella che verrà creato automaticamente da Spring Boot. Il codice seguente ignora i getters metodi e setters .

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

4. Modificare il file della classe di avvio per visualizzare il contenuto seguente.

   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.boot.context.event.ApplicationReadyEvent;
   import org.springframework.context.ApplicationListener;
   import org.springframework.context.annotation.Bean;
   import org.springframework.data.repository.CrudRepository;
   
   import java.util.stream.Stream;
   
   @SpringBootApplication
   public class DemoApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(DemoApplication.class, args);
       }
   
       @Bean
       ApplicationListener<ApplicationReadyEvent> basicsApplicationListener(TodoRepository repository) {
           return event->repository
               .saveAll(Stream.of("A", "B", "C").map(name->new Todo("configuration", "congratulations, you have set up correctly!", true)).toList())
               .forEach(System.out::println);
       }
   
   }
   
   interface TodoRepository extends CrudRepository<Todo, Long> {
   
   }
   

   Suggerimento

   In questa esercitazione non sono presenti operazioni di autenticazione nelle configurazioni o nel codice. Tuttavia, la connessione ai servizi di Azure richiede l'autenticazione. Per completare l'autenticazione, è necessario usare Azure Identity. Spring Cloud Azure usa DefaultAzureCredential, che la libreria di identità Azure fornisce per ottenere le credenziali senza modifiche al codice.

   DefaultAzureCredential supporta più metodi di autenticazione e determina il metodo da usare in fase di esecuzione. Questo approccio consente all'app di usare metodi di autenticazione diversi in ambienti diversi (ad esempio ambienti locali e di produzione) senza implementare codice specifico dell'ambiente. Per altre informazioni, vedere DefaultAzureCredential.

   Per completare l'autenticazione negli ambienti di sviluppo locali, è possibile usare Azure CLI, Visual Studio Code, PowerShell o altri metodi. Per altre informazioni, vedere autenticazione Azure in ambienti di sviluppo Java. Per completare l'autenticazione negli ambienti di hosting Azure, è consigliabile usare l'identità gestita assegnata dall'utente. Per altre informazioni, vedere Che sono identità gestite per le risorse Azure?

5. Avviare l’applicazione. L'applicazione archivia i dati nel database. Verranno visualizzati log simili all'esempio seguente:

   2023-02-01 10:22:36.701 DEBUG 7948 --- [main] o.s.jdbc.core.JdbcTemplate : Executing prepared SQL statement [INSERT INTO todo (description, details, done) VALUES (?, ?, ?)]    
   com.example.demo.Todo@4bdb04c8
   

Distribuire su Azure Spring Apps

Ora che l'applicazione Spring Boot è in esecuzione in locale, è possibile spostarla nell'ambiente di produzione. Azure Spring Apps semplifica la distribuzione di applicazioni Spring Boot in Azure senza modifiche al codice. Il servizio gestisce l'infrastruttura delle applicazioni Spring per consentire agli sviluppatori di concentrarsi sul codice. Azure Spring Apps offre la gestione del ciclo di vita usando monitoraggio e diagnostica completi, gestione della configurazione, individuazione dei servizi, integrazione CI/CD, distribuzioni blu-verde e altro ancora. Per distribuire l'applicazione in Azure Spring Apps, vedere Distribuire la prima applicazione in Azure Spring Apps.

Passaggi successivi