Delen via

Quickstart: Java en JDBC gebruiken met Azure Database for PostgreSQL - Flexible Server

  • Artikel

VAN TOEPASSING OP: Azure Database for PostgreSQL - Flexibele server

In dit artikel wordt gedemonstreerd hoe u een voorbeeldtoepassing maakt die gebruikmaakt van Java en JDBC om informatie op te slaan en op te halen in flexibele Azure Database for PostgreSQL-server.

JDBC is de standaard Java-API voor het maken van verbinding met traditionele relationele databases.

In dit artikel bevatten we twee verificatiemethoden: Microsoft Entra-verificatie en PostgreSQL-verificatie. Op het tabblad Wachtwoordloos wordt de Microsoft Entra-verificatie weergegeven en op het tabblad Wachtwoord wordt de PostgreSQL-verificatie weergegeven.

Microsoft Entra-verificatie is een mechanisme voor het maken van verbinding met Azure Database for PostgreSQL met behulp van identiteiten die zijn gedefinieerd in Microsoft Entra-id. Met Microsoft Entra-verificatie kunt u databasegebruikersidentiteiten en andere Microsoft-services op een centrale locatie beheren, waardoor het beheer van machtigingen wordt vereenvoudigd.

PostgreSQL-verificatie maakt gebruik van accounts die zijn opgeslagen in PostgreSQL. Als u ervoor kiest om wachtwoorden als referenties voor de accounts te gebruiken, worden deze referenties opgeslagen in de user tabel. Omdat deze wachtwoorden zijn opgeslagen in PostgreSQL, moet u de rotatie van de wachtwoorden zelf beheren.

Vereisten

De werkomgeving voorbereiden

Gebruik eerst de volgende opdracht om enkele omgevingsvariabelen in te stellen.

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)

Vervang de tijdelijke aanduidingen door de volgende waarden, die overal in dit artikel worden gebruikt:

  • <YOUR_DATABASE_SERVER_NAME>: De naam van uw flexibele Azure Database for PostgreSQL-serverexemplaren, die uniek moeten zijn in Azure.
  • <YOUR_DATABASE_NAME>: De databasenaam van het exemplaar van de flexibele Azure Database for PostgreSQL-server, die uniek moet zijn binnen Azure.
  • <YOUR_AZURE_REGION>: de Azure-regio die moet worden gebruikt. U kunt standaard eastus gebruiken, maar we raden u aan om een regio dichtbij uw locatie te configureren. U kunt de volledige lijst met beschikbare regio's bekijken door deze in te voeren az account list-locations.
  • <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>: De gebruikersnaam van uw flexibele Azure Database for PostgreSQL-serverexemplaren. Zorg ervoor dat de gebruikersnaam een geldige gebruiker is in uw Microsoft Entra-tenant.
  • <YOUR_LOCAL_IP_ADDRESS>: Het IP-adres van uw lokale computer, van waaruit u uw Spring Boot-toepassing uitvoert. Een handige manier om het te vinden is door whatismyip.akamai.com te openen.

Belangrijk

Als u deze instelling instelt <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>, moet de gebruikersnaam al aanwezig zijn in uw Microsoft Entra-tenant of kunt u geen Microsoft Entra-gebruiker maken in uw database.

Maak vervolgens een resourcegroep met de volgende opdracht:

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

Een exemplaar van een flexibele Azure Database for PostgreSQL-server maken

In de volgende secties wordt beschreven hoe u uw database-exemplaar maakt en configureert.

Een exemplaar van een flexibele Azure Database for PostgreSQL-server maken en beheerdersgebruiker instellen

Het eerste wat u maakt, is een beheerd exemplaar van een flexibele Azure Database for PostgreSQL-server.

Notitie

Meer gedetailleerde informatie over het maken van azure Database for PostgreSQL flexibele serverexemplaren vindt u in Azure Database for PostgreSQL flexibele serverexemplaren maken met behulp van De Azure-portal.

Als u Azure CLI gebruikt, voert u de volgende opdracht uit om te controleren of deze voldoende machtigingen heeft:

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

Voer de volgende opdracht uit om de server te maken:

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

Als u een Microsoft Entra-beheerder wilt instellen nadat u de server hebt gemaakt, volgt u de stappen in Microsoft Entra-rollen beheren in Azure Database for PostgreSQL - Flexible Server.

Belangrijk

Bij het instellen van een beheerder wordt een nieuwe gebruiker met volledige beheerdersbevoegdheden toegevoegd aan de Azure Database for PostgreSQL Flexibele serverinstantie van de Azure-database. U kunt meerdere Microsoft Entra-beheerders maken per azure Database for PostgreSQL flexibele serverinstantie.

Ondervindt u problemen? Laat het ons weten.

Een firewallregel configureren voor uw flexibele serverexemplaren van Azure Database for PostgreSQL

Azure Database for PostgreSQL Flexibele serverexemplaren worden standaard beveiligd. Ze hebben een firewall die geen enkele binnenkomende verbinding toestaat. Om uw database te kunnen gebruiken, moet u een firewallregel toevoegen waarmee het lokale IP-adres toegang krijgt tot de databaseserver.

Aangezien u aan het begin van dit artikel een lokaal IP-adres hebt geconfigureerd, kunt u de firewall van de server openen door de volgende opdracht uit te voeren:

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

Als u verbinding maakt met uw flexibele Server-exemplaar van Azure Database for PostgreSQL vanaf Windows-subsysteem voor Linux (WSL) op een Windows-computer, moet u de WSL-host-id toevoegen aan uw firewall.

Haal het IP-adres van uw hostcomputer op door de volgende opdracht uit te voeren in WSL:

cat /etc/resolv.conf

Kopieer het IP-adres na de term nameserveren gebruik vervolgens de volgende opdracht om een omgevingsvariabele in te stellen voor het WSL IP-adres:

AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

Gebruik vervolgens de volgende opdracht om de firewall van de server te openen naar uw WSL-app:

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

Een flexibele Azure Database for PostgreSQL-serverdatabase configureren

Maak een nieuwe database met behulp van de volgende opdracht:

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

Een niet-beheerdersgebruiker voor een flexibele Azure Database for PostgreSQL-server maken en machtigingen verlenen

Maak vervolgens een niet-beheerder en verdeel alle machtigingen aan de database.

Notitie

Meer gedetailleerde informatie over het beheren van flexibele servergebruikers van Azure Database for PostgreSQL vindt u in Microsoft Entra-gebruikers beheren - Azure Database for PostgreSQL - Flexible Server.

Maak een SQL-script met de naam create_ad_user.sql voor het maken van een niet-beheerdersgebruiker. Voeg de volgende inhoud toe en sla deze lokaal op:

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

Gebruik vervolgens de volgende opdracht om het SQL-script uit te voeren om de niet-beheerdersgebruiker van Microsoft Entra te maken:

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

Gebruik nu de volgende opdracht om het tijdelijke SQL-scriptbestand te verwijderen:

rm create_ad_user.sql

Een nieuw Java-project maken

Maak met uw favoriete IDE een nieuw Java-project met Java 8 of hoger en voeg een pom.xml bestand toe in de hoofdmap met de volgende inhoud:

<?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>

Dit bestand is een Apache Maven waarmee het project wordt geconfigureerd voor gebruik:

  • Java 8
  • Een recent PostgreSQL-stuurprogramma voor Java

Een configuratiebestand voorbereiden om verbinding te maken met een flexibele Azure Database for PostgreSQL-server

Maak een src/main/resources/application.properties-bestand en voeg vervolgens de volgende inhoud toe:

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

Notitie

De configuratie-eigenschap url heeft ?serverTimezone=UTC het JDBC-stuurprogramma toegevoegd om TLS (Transport Layer Security) te gebruiken bij het maken van verbinding met de database. Het is verplicht TLS te gebruiken met azure Database for PostgreSQL flexibele server en het is een goede beveiligingspraktijk.

Een SQL-bestand maken om het databaseschema te genereren

U gebruikt een src/main/resources/schema.sql -bestand om een databaseschema te maken. Maak het bestand met de volgende inhoud:

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

De toepassing coderen

Verbinding maken met de database

Voeg vervolgens de Java-code toe die JDBC gebruikt om gegevens op te slaan en op te halen uit uw flexibele Azure Database for PostgreSQL-serverexemplaren.

Maak een src/main/java/DemoApplication.java-bestand en voeg de volgende inhoud toe:

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

Ondervindt u problemen? Laat het ons weten.

Deze Java-code gebruikt de application.properties en de schema.sql bestanden die we eerder hebben gemaakt, om verbinding te maken met het flexibele serverexemplaren van Azure Database for PostgreSQL en een schema te maken waarmee onze gegevens worden opgeslagen.

In dit bestand kunt u zien dat we commentaar hebben gemaakt van methoden voor het invoegen, lezen, bijwerken en verwijderen van gegevens. We gaan deze methoden coderen in de rest van dit artikel en u kunt dan de commentaartekens /* en */ per methode verwijderen.

Notitie

De databasereferenties worden opgeslagen in de eigenschappen users en password van het bestand application.properties. Deze referenties worden gebruikt bij het uitvoeren van DriverManager.getConnection(properties.getProperty("url"), properties);, omdat het eigenschappenbestand als argument wordt doorgegeven.

U kunt nu deze main-klasse uitvoeren met uw favoriete tool:

  • Klik in uw IDE met de rechtermuisknop op de klasse DemoApplication en voer deze uit.
  • Als u Maven gebruikt, kunt u de toepassing uitvoeren met de volgende opdracht: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".

De toepassing moet verbinding maken met het flexibele serverexemplaren van Azure Database for PostgreSQL, een databaseschema maken en vervolgens de verbinding sluiten, zoals u zou moeten zien in de consolelogboeken:

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

Een domeinklasse maken

Maak een nieuwe Java-klasse Todo, naast de klasse DemoApplication, en voeg de volgende code toe:

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

Deze klasse is een domeinmodel dat is toegewezen aan de tabel todo die u eerder hebt gemaakt tijdens het uitvoeren van het script schema.sql.

Gegevens invoegen in flexibele Azure Database for PostgreSQL-server

Voeg na de methode main in het bestand src/main/java/DemoApplication.java de volgende methode toe om gegevens in te voegen in de 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();
}

U kunt nu de commentaartekens verwijderen van de twee volgende regels in de methode main:

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

Als u nu de main-klasse uitvoert, zou dit de volgende uitvoer moeten opleveren:

[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

Gegevens lezen van flexibele Azure Database for PostgreSQL-server

Laten we de gegevens lezen die u eerder hebt ingevoegd om te controleren of onze code goed werkt.

Voeg in het bestand src/main/java/DemoApplication.java, na de methode insertData, de volgende methode toe om gegevens te lezen uit de 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;
}

U kunt nu de commentaartekens verwijderen van de volgende regel in de methode main:

todo = readData(connection);

Als u nu de main-klasse uitvoert, zou dit de volgende uitvoer moeten opleveren:

[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

Gegevens bijwerken in flexibele Azure Database for PostgreSQL-server

Laten we de gegevens bijwerken die we eerder hebben ingevoegd.

Voeg in het bestand src/main/java/DemoApplication.java, na de methode readData, de volgende methode toe om gegevens bij te werken in de 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);
}

U kunt nu de commentaartekens verwijderen van de twee volgende regels in de methode main:

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

Als u nu de main-klasse uitvoert, zou dit de volgende uitvoer moeten opleveren:

[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

Gegevens verwijderen in flexibele Azure Database for PostgreSQL-server

Laten we ten slotte de gegevens verwijderen die we eerder hebben ingevoegd.

Voeg in het bestand src/main/java/DemoApplication.java, na de methode updateData, de volgende methode toe om gegevens te verwijderen uit de 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);
}

U kunt nu de commentaartekens verwijderen van de volgende regel in de methode main:

deleteData(todo, connection);

Als u nu de main-klasse uitvoert, zou dit de volgende uitvoer moeten opleveren:

[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

Resources opschonen

Gefeliciteerd U hebt een Java-toepassing gemaakt die gebruikmaakt van JDBC voor het opslaan en ophalen van gegevens van flexibele Azure Database for PostgreSQL-server.

Als u alle resources wilt opschonen die tijdens deze quickstart zijn gebruikt, verwijdert u de resourcegroep. Dit kan met de volgende opdracht:

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

Volgende stappen

Een database migreren met behulp van Exporteren en importeren