Schnellstart: Verwenden von Java und BEFEHLEN mit Azure-Datenbank für PostgreSQL – Flexibler Server

  • Artikel

GILT FÜR: Azure Database for PostgreSQL – Flexible Server

In diesem Artikel wird das Erstellen einer Beispielanwendung veranschaulicht, die Java und VORGANG zum Speichern und Abrufen von Informationen in azure Database for PostgreSQL flexiblen Server verwendet.

JDBC ist die Standard-Java-API, um eine Verbindung mit herkömmlichen relationalen Datenbanken herzustellen.

In diesem Artikel werden zwei Authentifizierungsmethoden verwendet: Microsoft Entra-Authentifizierung und PostgreSQL-Authentifizierung. Die Registerkarte Kennwortlos zeigt die Microsoft Entra-Authentifizierung und die Registerkarte Kennwort die PostgreSQL-Authentifizierung.

Die Microsoft Entra-Authentifizierung ist ein Mechanismus zum Herstellen einer Verbindung mit Azure Database for PostgreSQL unter Verwendung von Identitäten, die in Microsoft Entra ID definiert sind. Mit der Microsoft Entra-Authentifizierung können Sie Datenbankbenutzeridentitäten und andere Microsoft-Dienste an einem zentralen Ort verwalten, wodurch die Berechtigungsverwaltung vereinfacht wird.

Die PostgreSQL-Authentifizierung verwendet Konten, die in PostgreSQL gespeichert sind. Wenn Sie Kennwörter als Anmeldeinformationen für die Konten verwenden möchten, werden diese Anmeldeinformationen in der user-Tabelle gespeichert. Da diese Kennwörter in PostgreSQL gespeichert sind, müssen Sie die Rotation der Kennwörter selbst verwalten.

Voraussetzungen

Vorbereiten der Arbeitsumgebung

Richten Sie zunächst mithilfe des folgenden Befehls einige Umgebungsvariablen ein.

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)

Ersetzen Sie die Platzhalter durch die folgenden Werte, die in diesem Artikel verwendet werden:

  • <YOUR_DATABASE_SERVER_NAME>: Der Name Ihrer Azure-Datenbank für flexible Serverinstanz für PostgreSQL, die in Azure eindeutig sein sollte.
  • <YOUR_DATABASE_NAME>: Der Datenbankname der Azure-Datenbank für flexible Serverinstanz für PostgreSQL, die innerhalb von Azure eindeutig sein sollte.
  • <YOUR_AZURE_REGION>: Die zu verwendende Azure-Region. Sie können standardmäßig eastus verwenden, wir empfehlen aber, eine Region zu konfigurieren, die näher an Ihrem Standort liegt. Die vollständige Liste der verfügbaren Regionen wird angezeigt, wenn Sie az account list-locations eingeben.
  • <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>: Der Benutzername Ihrer Azure-Datenbank für flexible Serverinstanz von PostgreSQL. Stellen Sie sicher, dass die Benutzernamen zu gültigen Benutzer*innen in Ihrem Microsoft Entra-Mandanten gehören.
  • <YOUR_LOCAL_IP_ADDRESS>: Die IP-Adresse Ihres lokalen Computers, auf dem Sie die Spring Boot-Anwendung ausführen. Sie können sie ganz einfach ermitteln, indem Sie whatismyip.akamai.com öffnen.

Wichtig

Wenn Sie <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME> festlegen, muss der Benutzername bereits in Ihrem Microsoft Entra-Mandanten vorhanden sein. Andernfalls können Sie keine*n Microsoft Entra-Benutzer*in in Ihrer Datenbank erstellen.

Erstellen Sie nun mithilfe des folgenden Befehls eine Ressourcengruppe:

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

Erstellen einer Azure-Datenbank für flexible Serverinstanz für PostgreSQL

In den folgenden Abschnitten wird beschrieben, wie Sie Ihre Datenbankinstanz erstellen und konfigurieren.

Erstellen einer Azure-Datenbank für flexible Serverinstanz für PostgreSQL und Einrichten eines Administratorbenutzers

Als Erstes erstellen Sie eine verwaltete Azure-Datenbank für flexible Serverinstanz von PostgreSQL.

Hinweis

Ausführlichere Informationen zum Erstellen von Flexiblen Serverinstanzen für Azure Database für PostgreSQL finden Sie unter Erstellen einer flexiblen Azure-Datenbank für PostgreSQL-Serverinstanz mithilfe der Azure-Portal.

Wenn Sie die Azure CLI verwenden, führen Sie den folgenden Befehl aus, um sicherzustellen, dass sie über ausreichende Berechtigungen verfügt:

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

Führen Sie den folgenden Befehl aus, um den Server zu erstellen:

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

Führen Sie zum Einrichten eines Microsoft Entra-Administrators nach dem Erstellen des Servers die Schritte unter Verwalten von Microsoft Entra-Rollen in Azure Database for PostgreSQL – Flexibler Server aus.

Wichtig

Beim Einrichten eines Administrators wird ein neuer Benutzer mit vollständigen Administratorrechten zur Azure-Datenbank für Die Azure-Datenbank für PostgreSQL flexible Serverinstanz hinzugefügt. Sie können mehrere Microsoft Entra-Administratoren pro Azure-Datenbank für flexible Serverinstanz von PostgreSQL erstellen.

Treten Probleme auf? Teilen Sie es uns mit.

Konfigurieren einer Firewallregel für Ihre Azure-Datenbank für flexible Serverinstanz für PostgreSQL

Azure Database for PostgreSQL flexible Serverinstanzen sind standardmäßig gesichert. Sie besitzen eine Firewall, die keine eingehenden Verbindungen zulässt. Damit Sie die Datenbank verwenden können, müssen Sie eine Firewallregel hinzufügen, die den Zugriff der lokalen IP-Adresse auf den Datenbankserver zulässt.

Da Sie die lokale IP-Adresse zu Beginn dieses Artikels konfiguriert haben, können Sie die Firewall des Servers öffnen, indem Sie den folgenden Befehl ausführen:

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

Wenn Sie eine Verbindung mit Ihrer Azure-Datenbank für flexible Serverinstanz von Windows-Subsystem für Linux (WSL) auf einem Windows-Computer herstellen, müssen Sie der Firewall die WSL-Host-ID hinzufügen.

Rufen Sie die IP-Adresse Ihres Hostcomputers ab, indem Sie den folgenden Befehl in WSL ausführen:

cat /etc/resolv.conf

Kopieren Sie die IP-Adresse nach dem Ausdruck nameserver, und verwenden Sie dann den folgenden Befehl, um eine Umgebungsvariable für die WSL-IP-Adresse festzulegen:

AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

Verwenden Sie dann den folgenden Befehl, um die Firewall des Servers für Ihre WSL-basierte App zu öffnen:

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

Konfigurieren einer Azure-Datenbank für flexible Serverdatenbank für PostgreSQL

Erstellen Sie mit dem folgenden Befehl eine neue Datenbank:

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

Erstellen einer Azure-Datenbank für flexiblen Server, der kein Administrator ist, und Erteilen von Berechtigungen

Erstellen Sie nun einen Nicht-Administratorbenutzer, und gewähren Sie ihm alle Berechtigungen für die Datenbank.

Hinweis

Ausführlichere Informationen zum Verwalten von Azure Database für flexible Serverbenutzer in "Verwalten von Microsoft Entra-Benutzern – Azure Database for PostgreSQL – Flexible Server" finden Sie unter "Verwalten von Microsoft Entra-Benutzern".

Erstellen Sie ein SQL-Skript namens create_ad_user.sql zum Erstellen eines Nicht-Administratorbenutzers. Fügen Sie den folgenden Inhalt hinzu, und speichern Sie das Skript lokal:

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

Verwenden Sie dann den folgenden Befehl, um das SQL-Skript zum Erstellen des/der Microsoft Entra-Benutzers/-Benutzerin ohne Administratorrechte auszuführen:

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

Verwenden Sie nun den folgenden Befehl, um die temporäre SQL-Skriptdatei zu entfernen:

rm create_ad_user.sql

Erstellen eines neuen Java-Projekts

Erstellen Sie mithilfe Ihrer bevorzugten integrierten Entwicklungsumgebung (Integrated Development Environment, IDE) ein neues Java-Projekt mit Java 8 oder höher, und fügen Sie im Stammverzeichnis eine Datei pom.xml mit folgendem Inhalt hinzu:

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

Dabei handelt es sich um eine Apache Maven-Datei, die das Projekt für die Verwendung folgender Komponenten konfiguriert:

  • Java 8
  • Aktueller PostgreSQL-Treiber für Java

Vorbereiten einer Konfigurationsdatei zum Herstellen einer Verbindung mit Azure-Datenbank für Einen flexiblen Server für PostgreSQL

Erstellen Sie eine Datei src/main/resources/application.properties, und fügen Sie ihr dann den folgenden Inhalt hinzu:

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

Hinweis

An die Konfigurationseigenschaft url ist ?serverTimezone=UTC angefügt, um den JDBC-Treiber anzuweisen, beim Herstellen einer Verbindung mit der Datenbank TLS (Transport Layer Security) zu verwenden. Es ist obligatorisch, TLS mit Azure Database für flexiblen Server für PostgreSQL zu verwenden, und es ist eine bewährte Sicherheitspraxis.

Erstellen einer SQL-Datei zum Generieren des Datenbankschemas

Sie verwenden eine Datei vom Typ src/main/resources/schema.sql, um ein Datenbankschema zu erstellen. Erstellen Sie diese Datei mit folgendem Inhalt:

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

Codieren der Anwendung

Herstellen der Verbindung mit der Datenbank

Fügen Sie als Nächstes den Java-Code hinzu, der MITHILFE VON SHAPE Daten aus Ihrer Azure-Datenbank für flexible Serverinstanz für PostgreSQL speichert und abruft.

Erstellen Sie eine Datei src/main/java/DemoApplication.java, und fügen Sie den folgenden Inhalt hinzu:

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

Treten Probleme auf? Teilen Sie es uns mit.

Dieser Java-Code verwendet die dateien application.properties und schema.sql, die wir zuvor erstellt haben, um eine Verbindung mit der flexiblen Azure-Serverinstanz für PostgreSQL herzustellen und ein Schema zu erstellen, das unsere Daten speichert.

Sie sehen, dass in dieser Datei Methoden zum Einfügen, Lesen, Aktualisieren und Löschen von Daten kommentiert wurden: Diese Methoden werden im verbleibenden Artikel codiert, und Sie können nacheinander die Auskommentierung aufheben.

Hinweis

Die Datenbankanmeldeinformationen werden in den Eigenschaften user und password der Datei application.properties gespeichert. Diese Anmeldeinformationen werden bei der Ausführung von DriverManager.getConnection(properties.getProperty("url"), properties); verwendet, da die Eigenschaftendatei als Argument übergeben wird.

Sie können diese Hauptklasse nun mit Ihrem bevorzugten Tool ausführen:

  • Bei Verwendung Ihrer IDE sollten Sie mit der rechten Maustaste auf die Klasse DemoApplication klicken und diese ausführen können.
  • Bei Verwendung von Maven können Sie die Anwendung mithilfe von mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication" ausführen.

Die Anwendung sollte eine Verbindung mit der flexiblen Azure-Datenbank für PostgreSQL-Serverinstanz herstellen, ein Datenbankschema erstellen und dann die Verbindung schließen, wie in den Konsolenprotokollen zu sehen ist:

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

Erstellen einer Domänenklasse

Erstellen Sie neben der Klasse DemoApplication eine neue Todo Java-Klasse, und fügen Sie den folgenden Code hinzu:

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

Bei dieser Klasse handelt es sich um ein Domänenmodell, das der todo-Tabelle zugeordnet ist, die Sie beim Ausführen des Skripts schema.sql erstellt haben.

Einfügen von Daten in azure-Datenbank für flexiblen Server für PostgreSQL

Fügen Sie in der Datei src/main/java/DemoApplication.java nach der main-Methode die folgende Methode ein, um Daten in die Datenbank einzufügen:

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

Sie können die Auskommentierung der beiden folgenden Zeilen in der Methode main aufheben:

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

Das Ausführen der Hauptklasse sollte nun die folgende Ausgabe ergeben:

[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

Lesen von Daten aus der Azure-Datenbank für flexiblen Server für PostgreSQL

Lesen Sie die zuvor eingefügten Daten, um zu überprüfen, ob der Code ordnungsgemäß funktioniert.

Fügen Sie in der Datei src/main/java/DemoApplication.java nach der insertData-Methode die folgende Methode ein, um Daten aus der Datenbank zu lesen:

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

Sie können die Auskommentierung der folgenden Zeile nun in der Methode main aufheben:

todo = readData(connection);

Das Ausführen der Hauptklasse sollte nun die folgende Ausgabe ergeben:

[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

Aktualisieren von Daten in Azure-Datenbank für flexiblen Server für PostgreSQL

Aktualisieren Sie die zuvor eingefügten Daten.

Fügen Sie in der Datei src/main/java/DemoApplication.java nach der readData-Methode die folgende Methode ein, um die Daten in der Datenbank zu aktualisieren:

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

Sie können die Auskommentierung der beiden folgenden Zeilen in der Methode main aufheben:

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

Das Ausführen der Hauptklasse sollte nun die folgende Ausgabe ergeben:

[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

Löschen von Daten in der Azure-Datenbank für flexiblen Server für PostgreSQL

Löschen Sie die zuvor eingefügten Daten.

Fügen Sie in der Datei src/main/java/DemoApplication.java nach der updateData-Methode die folgende Methode ein, um die Daten in der Datenbank zu löschen:

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

Sie können die Auskommentierung der folgenden Zeile nun in der Methode main aufheben:

deleteData(todo, connection);

Das Ausführen der Hauptklasse sollte nun die folgende Ausgabe ergeben:

[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

Bereinigen von Ressourcen

Herzlichen Glückwunsch! Sie haben eine Java-Anwendung erstellt, die MITHILFE VON SCRIPT Daten aus der Azure-Datenbank für PostgreSQL flexiblen Server speichert und abruft.

Löschen Sie die Ressourcengruppe mit dem folgenden Befehl, um alle in dieser Schnellstartanleitung verwendeten Ressourcen zu bereinigen:

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

Nächste Schritte

Migrieren der Datenbank mit Export und Import