Schnellstart: Verwenden von Java und SDL für Azure HorizonDB (Vorschau)

In diesem Artikel wird veranschaulicht, wie Sie eine Beispielanwendung erstellen, die Java und JDBC verwendet, um Informationen in Azure HorizonDB (Vorschau) zu speichern und abzurufen.

JDBC ist die Standard-Java-API zum Herstellen von Verbindungen mit herkömmlichen relationalen Datenbanken.

Die Schritte in diesem Artikel umfassen die PostgreSQL-Authentifizierung.

Die PostgreSQL-Authentifizierung verwendet Konten, die in PostgreSQL gespeichert sind, und Sie müssen die Drehung der Kennwörter selbst verwalten.

Voraussetzungen

• Ein Azure Konto. Falls Sie noch kein Konto haben, können Sie eine kostenlose Testversion verwenden.
• Azure Cloud Shell oder Azure CLI. Verwenden Sie Azure Cloud Shell, damit Sie automatisch authentifiziert werden und Zugriff auf alle benötigten Tools haben.
• Ein unterstütztes Java Development Kit, Version 8 (in Cloud Shell enthalten).
• Das Apache Maven-Buildtool

Vorbereiten der Arbeitsumgebung

Verwenden Sie zunächst den folgenden Befehl, um einige Umgebungsvariablen einzurichten.

export AZ_RESOURCE_GROUP=database-workshop
export AZ_DATABASE_CLUSTER_NAME=<YOUR_DATABASE_CLUSTER_NAME>
export AZ_DATABASE_NAME=<YOUR_DATABASE_NAME>
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_POSTGRESQL_ADMIN_USERNAME=demo
export AZ_POSTGRESQL_ADMIN_PASSWORD=<YOUR_POSTGRESQL_ADMIN_PASSWORD>
export AZ_POSTGRESQL_NON_ADMIN_USERNAME=demo-non-admin
export AZ_POSTGRESQL_NON_ADMIN_PASSWORD=<YOUR_POSTGRESQL_NON_ADMIN_PASSWORD>
export AZ_LOCAL_IP_ADDRESS=<YOUR_LOCAL_IP_ADDRESS>

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

• <YOUR_DATABASE_CLUSTER_NAME>: Der Name Ihres Azure HorizonDB-Clusters, der in Ihrer Azure-Abonnement- und Ressourcengruppe eindeutig sein sollte.
• <YOUR_DATABASE_NAME>: Der Datenbankname, den Sie in Ihrem Azure HorizonDB-Cluster verwenden.
• <YOUR_AZURE_REGION>: Die zu verwendende Azure-Region. Sie können australiaeast standardmäßig verwenden, sollten jedoch eine Region konfigurieren, die näher an Ihrem Wohnort liegt. Die vollständige Liste der verfügbaren Regionen wird angezeigt, wenn Sie az account list-locations eingeben.
• <YOUR_POSTGRESQL_ADMIN_PASSWORD> und <YOUR_POSTGRESQL_NON_ADMIN_PASSWORD>: Das Kennwort Ihres Azure HorizonDB-Clusters. Dieses Kennwort sollte mindestens acht Zeichen lang sein. Es muss Zeichen aus drei der folgenden Kategorien enthalten: englische Großbuchstaben, englische Kleinbuchstaben, Zahlen (0–9) und nicht alphanumerische Zeichen (!, $, #, % usw.).
• <YOUR_LOCAL_IP_ADDRESS>: Die IP-Adresse Ihres lokalen Computers, von dem Aus Sie Die Spring Boot-Anwendung ausführen. Eine praktische Möglichkeit, dies herauszufinden, ist, whatismyip.akamai.com zu öffnen.

Erstellen Sie nun mithilfe des folgenden Befehls eine Ressourcengruppe:

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

Erstellen eines Azure HorizonDB-Clusters

In den folgenden Abschnitten wird beschrieben, wie Sie Ihren Datenbankcluster erstellen und konfigurieren.

Erstellen eines Azure HorizonDB-Clusters

Administratorbenutzer einrichten

Erstellen Sie zunächst eine verwaltete Azure HorizonDB-Instanz.

az horizondb create \
  --resource-group $AZ_RESOURCE_GROUP \
  --name $AZ_DATABASE_CLUSTER_NAME \
  --location $AZ_LOCATION \
  --version 17 \
  --administrator-login $AZ_POSTGRESQL_ADMIN_USERNAME \
  --administrator-login-password $AZ_POSTGRESQL_ADMIN_PASSWORD \
  --v-cores 2 \
  --yes \
  --output tsv

Dieser Befehl erstellt einen kleinen Azure HorizonDB-Cluster.

Treten Probleme auf? Informieren Sie uns darüber.

Konfigurieren einer Firewallregel für Ihre Azure HorizonDB-Instanz

Azure HorizonDB-Instanzen sind standardmäßig sicher. Sie verfügen über eine Firewall, die alle eingehenden Verbindungen blockiert. Um Ihre Datenbank zu verwenden, fügen Sie eine Firewallregel hinzu, die Ihrer lokalen IP-Adresse Zugriff auf den Datenbankserver gewährt.

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

az horizondb firewall-rule create \
  --resource-group $AZ_RESOURCE_GROUP \
  --cluster-name $AZ_DATABASE_CLUSTER_NAME \
  --firewall-rule-name $AZ_DATABASE_CLUSTER_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 Ihrem Azure HorizonDB-Cluster 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, die dem Ausdruck nameserverfolgt, 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 horizondb firewall-rule create \
  --resource-group $AZ_RESOURCE_GROUP \
  --cluster-name $AZ_DATABASE_CLUSTER_NAME \
  --firewall-rule-name $AZ_DATABASE_CLUSTER_NAME-database-allow-local-ip \
  --start-ip-address $AZ_WSL_IP_ADDRESS \
  --end-ip-address $AZ_WSL_IP_ADDRESS \
  --output tsv

Erstellen einer Azure HorizonDB-Datenbank

Erstellen Sie ein SQL-Skript namens create_database.sql , um eine neue Datenbank in Ihrem Cluster zu erstellen. Fügen Sie den folgenden Inhalt hinzu, und speichern Sie die Datei lokal:

cat << EOF > create_database.sql
CREATE DATABASE "$AZ_DATABASE_NAME";
EOF

Führen Sie diesen Befehl aus, um den vollqualifizierten Domänennamen Ihrer Azure HorizonDB abzurufen und den Wert clusterName zu kopieren:

az horizondb show \
  --resource-group $AZ_RESOURCE_GROUP \
  --name $AZ_DATABASE_CLUSTER_NAME \
  --query "{clusterName:properties.fullyQualifiedDomainName, adminUser:properties.administratorLogin}" \
  --output table

Kopieren Sie den clusterName Wert, und verwenden Sie ihn im folgenden Befehl:

AZ_HORIZONDB_FQDN=<the-copied-clusterName-value>

Führen Sie dann den folgenden Befehl aus, um das SQL-Skript auszuführen und Ihre Datenbank zu erstellen:

psql "host=$AZ_HORIZONDB_FQDN user=$AZ_POSTGRESQL_ADMIN_USERNAME dbname=$AZ_DATABASE_NAME port=5432 password=$AZ_POSTGRESQL_ADMIN_PASSWORD sslmode=require" < create_database.sql

Führen Sie nun den folgenden Befehl aus, um die temporäre SQL-Skriptdatei zu löschen:

rm create_database.sql

Erstellen eines Azure HorizonDB-Benutzers ohne Administratorrechte und Erteilen von Berechtigungen

Erstellen Sie als Nächstes einen Benutzer ohne Administratorrechte und gewähren Sie ihm alle Berechtigungen für die Datenbank.

Erstellen Sie ein SQL-Skript mit dem Namen create_user.sql , um einen nichtadmin-Benutzer zu erstellen. Fügen Sie den folgenden Inhalt hinzu, und speichern Sie die Datei lokal:

cat << EOF > create_user.sql
CREATE ROLE "$AZ_POSTGRESQL_NON_ADMIN_USERNAME" WITH LOGIN PASSWORD '$AZ_POSTGRESQL_NON_ADMIN_PASSWORD';
GRANT ALL PRIVILEGES ON DATABASE $AZ_DATABASE_NAME TO "$AZ_POSTGRESQL_NON_ADMIN_USERNAME";
EOF

Führen Sie dann den folgenden Befehl aus, um das SQL-Skript auszuführen und den Microsoft Entra nichtadmin-Benutzer zu erstellen:

psql "host=$AZ_HORIZONDB_FQDN user=$AZ_POSTGRESQL_ADMIN_USERNAME dbname=$AZ_DATABASE_NAME port=5432 password=$AZ_POSTGRESQL_ADMIN_PASSWORD sslmode=require" < create_user.sql

Führen Sie nun den folgenden Befehl aus, um die temporäre SQL-Skriptdatei zu löschen:

rm create_user.sql

Erstellen eines neuen Java-Projekts

Erstellen Sie mit Ihrer bevorzugten IDE ein neues Java Projekt mithilfe von Java 8 oder höher. Fügen Sie eine pom.xml Datei im Stammverzeichnis mit dem folgenden 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>
    </dependencies>
</project>

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

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

Vorbereiten einer Konfigurationsdatei zum Herstellen einer Verbindung mit Azure HorizonDB

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

cat << EOF > src/main/resources/application.properties
url=jdbc:postgresql://${AZ_HORIZONDB_FQDN}:5432/${AZ_DATABASE_NAME}?sslmode=require
user=${AZ_POSTGRESQL_NON_ADMIN_USERNAME}
password=${AZ_POSTGRESQL_NON_ADMIN_PASSWORD}
EOF

Erstellen einer SQL-Datei zum Generieren des Datenbankschemas

Verwenden Sie eine Datei "src/main/resources/schema.sql ", um ein Datenbankschema zu erstellen. Erstellen Sie diese Datei mit dem folgenden Inhalt:

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

Codieren der Anwendung

Herstellen der Verbindung mit der Datenbank

Fügen Sie als Nächstes den Java-Code hinzu, der JDBC verwendet, um Daten in Ihrer Azure HorizonDB-Instanz zu speichern und daraus abzurufen.

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? Informieren Sie uns darüber.

Dieser Java Code verwendet die zuvor erstellten dateien application.properties und die Dateien schema.sql, um eine Verbindung mit der Azure HorizonDB-Instanz herzustellen und ein Schema zu erstellen, das unsere Daten speichert.

In dieser Datei können Sie sehen, dass wir die Methoden zum Einfügen, Lesen, Aktualisieren und Löschen von Daten auskommentiert haben: Diese Methoden implementieren wir im weiteren Verlauf dieses Artikels, und Sie können sie anschließend nacheinander wieder einkommentieren.

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 Azure HorizonDB-Instanz 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 Todo eine neue DemoApplication-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 HorizonDB

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 jetzt 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 erzeugen.

[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 Azure HorizonDB

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 erzeugen.

[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 HorizonDB

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 jetzt 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 erzeugen.

[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 Azure HorizonDB

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 erzeugen.

[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

Glückwunsch! Sie haben eine Java-Anwendung erstellt, die JDBC verwendet, um Daten in einer Azure HorizonDB-Instanz zu speichern und daraus abzurufen.

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

Verwandte Inhalte

• Quickstart: Verwenden von Python zum Verbinden und Abfragen von Daten in Azure HorizonDB (Vorschau)
• Mit Azure HorizonDB verbinden und abfragen (Vorschau)