Rychlý start: Použití Java a JDBC na flexibilním serveru Azure Database for PostgreSQL

Tento článek ukazuje, jak vytvořit ukázkovou aplikaci, která k ukládání a načítání informací v Azure Database for PostgreSQL používá Java a JDBC.

JDBC je standardní rozhraní API Java pro připojení k tradičním relačním databázím.

Tento článek obsahuje dvě metody ověřování: ověřování Microsoft Entra a ověřování PostgreSQL. Karta Bez hesla zobrazuje ověřování Microsoft Entra a karta Heslo zobrazuje ověřování PostgreSQL.

Ověřování Microsoft Entra je mechanismus pro připojení ke službě Azure Database for PostgreSQL pomocí identit definovaných v MICROSOFT Entra ID. Pomocí ověřování Microsoft Entra můžete spravovat identity uživatelů databáze a další služby Microsoft v centrálním umístění, což zjednodušuje správu oprávnění.

Ověřování PostgreSQL používá účty uložené v PostgreSQL. Pokud se rozhodnete používat hesla jako přihlašovací údaje pro účty, uložte tyto přihlašovací údaje do user tabulky. Vzhledem k tomu, že tato hesla jsou uložená v PostgreSQL, musíte spravovat rotaci hesel sami.

Požadavky

Příprava pracovního prostředí

Nejprve pomocí následujícího příkazu nastavte některé proměnné prostředí.

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)

Zástupné symboly nahraďte následujícími hodnotami, které se používají v tomto článku:

  • <YOUR_DATABASE_SERVER_NAME>: Název vašeho flexibilního serveru Azure Database for PostgreSQL, který by měl být jedinečný v celé službě Azure.
  • <YOUR_DATABASE_NAME>: Název databáze flexibilního serveru Azure Database for PostgreSQL, který by měl být v rámci Azure jedinečný.
  • <YOUR_AZURE_REGION>: Oblast Azure, která se má použít. Můžete použít eastus jako výchozí možnost, ale vyberte region, který je blíže místu, kde žijete. Pokud chcete zobrazit úplný seznam dostupných oblastí, zadejte az account list-locations.
  • <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>: Uživatelské jméno vašeho Azure Database for PostgreSQL flexibilního serveru. Ujistěte se, že uživatelské jméno je platným uživatelem ve vašem tenantovi Microsoft Entra.
  • <YOUR_LOCAL_IP_ADDRESS>: IP adresa místního počítače, ze kterého spouštíte aplikaci Spring Boot. Jedním z pohodlných způsobů, jak ji najít, je otevřít whatismyip.akamai.com.

Důležité

Při nastavování <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME> uživatel už musí existovat ve vašem tenantovi Microsoft Entra, jinak v databázi nelze vytvořit uživatele Microsoft Entra.

Dále pomocí následujícího příkazu vytvořte skupinu prostředků:

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

Vytvoření flexibilního serveru

Následující části popisují, jak vytvořit a nakonfigurovat instanci databáze.

Vytvoření flexibilního serveru a nastavení uživatele správce

Poznámka:

Podrobnější informace o vytváření Azure Database for PostgreSQL flexibilních serverů najdete v tématu Rychlý start: Vytvoření Azure Database for PostgreSQL flexibilního serveru.

Pokud používáte Azure CLI, spusťte následující příkaz, abyste měli jistotu, že má dostatečná oprávnění:

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

Spuštěním následujícího příkazu vytvořte server:

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

Pokud chcete po vytvoření serveru nastavit správce Microsoft Entra, postupujte podle pokynů v tématu Správa rolí Microsoft Entra ve službě Azure Database for PostgreSQL.

Důležité

Při nastavování správce přidáte nového uživatele s úplnými oprávněními správce do Azure databáze flexibilního serveru Azure Database for PostgreSQL. Na flexibilní server Azure Database for PostgreSQL můžete vytvořit více správců Microsoft Entra.

Máte nějaké problémy? Dejte nám vědět.

Konfigurujte pravidlo brány firewall pro instanci Azure Database for PostgreSQL

Azure Database for PostgreSQL flexibilní servery jsou ve výchozím nastavení zabezpečené. Mají bránu firewall, která blokuje všechna příchozí připojení. Chcete-li používat svou databázi, přidejte pravidlo brány firewall, které povolí přístup z vaší místní IP adresy k databázovému serveru.

Vzhledem k tomu, že jste na začátku tohoto článku nakonfigurovali místní IP adresu, můžete bránu firewall serveru otevřít spuštěním následujícího příkazu:

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

Pokud se k flexibilnímu serveru Azure Database for PostgreSQL připojujete ze systému Subsystém Windows pro Linux (WSL) v počítači se systémem Windows, musíte do brány firewall přidat ID hostitele systému WSL.

Spuštěním následujícího příkazu ve WSL získejte IP adresu vašeho hostitelského počítače:

cat /etc/resolv.conf

Zkopírujte IP adresu, která následuje za termínem nameserver, a pak pomocí následujícího příkazu nastavte proměnnou prostředí pro IP adresu WSL:

AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

Pak pomocí následujícího příkazu otevřete bránu firewall serveru pro vaši aplikaci založenou na 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

Nakonfigurujte databázi Azure Database for PostgreSQL

Pomocí následujícího příkazu vytvořte novou databázi:

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

Vytvoření uživatele bez oprávnění správce Azure Database for PostgreSQL a udělení oprávnění

Dále vytvořte uživatele bez oprávnění správce a udělte mu všechna oprávnění.

Poznámka:

Podrobnější informace o správě Azure Database for PostgreSQL uživatelů najdete v tématu Správa rolí Microsoft Entra v Azure Database for PostgreSQL.

Vytvořte skript SQL s názvem create_ad_user.sql pro vytvoření uživatele bez oprávnění správce. Přidejte následující obsah a uložte ho místně:

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

Potom pomocí následujícího příkazu spusťte skript SQL a vytvořte Microsoft Entra uživatele bez oprávnění správce:

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

Pomocí následujícího příkazu odeberte dočasný soubor skriptu SQL:

rm create_ad_user.sql

Vytvoření nového projektu v Javě

Pomocí svého oblíbeného integrovaného vývojového prostředí (IDE) vytvořte nový projekt Java pomocí Java 8 nebo novějšího. Do kořenového adresáře přidejte souborpom.xml s následujícím obsahem:

<?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.7.5</version>
      </dependency>
      <dependency>
        <groupId>com.azure</groupId>
        <artifactId>azure-identity-extensions</artifactId>
        <version>1.2.0</version>
      </dependency>
    </dependencies>
</project>

Tento soubor je soubor Apache Maven , který konfiguruje váš projekt tak, aby používal:

  • Java 8
  • Nedávný ovladač PostgreSQL pro Javu

Příprava konfiguračního souboru pro připojení ke službě Azure Database for PostgreSQL

Vytvořte soubor src/main/resources/application.properties a přidejte následující obsah:

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

Poznámka:

Vlastnost url v konfiguraci zahrnuje ?sslmode=require, aby ovladač JDBC při připojování k databázi používal TLS (Transport Layer Security). Použití protokolu TLS je povinné u Azure Database for PostgreSQL flexibilních serverů a je doporučeným postupem zabezpečení.

Vytvoření souboru SQL pro vygenerování schématu databáze

K vytvoření schématu databáze použijte soubor src/main/resources/schema.sql . Vytvořte tento soubor a přidejte následující obsah:

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

Kódování aplikace

Následující části vás provedou zápisem Java kódu, který se připojuje k databázi, definuje datový model a provádí základní operace CRUD.

Připojte se k databázi.

Dále přidejte kód Java, který používá JDBC k ukládání a načítání dat z flexibilního serveru Azure Database for PostgreSQL.

Vytvořte soubor src/main/java/DemoApplication.java a přidejte následující obsah:

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

Máte nějaké problémy? Dejte nám vědět.

Tento kód Java používá vlastnosti application.properties a soubory schema.sql, které jste vytvořili dříve, pro připojení k flexibilnímu serveru Azure Database for PostgreSQL a vytvoření schématu, které ukládá data.

V tomto souboru se metody vložení, čtení, aktualizace a odstranění dat zakomentují. Zbytek tohoto článku vás provede kódováním těchto metod a jeden po druhém je můžete odkomentovat.

Poznámka:

Přihlašovací údaje databáze jsou uloženy ve vlastnostech uživatele a hesla souboru application.properties. Kód používá tyto přihlašovací údaje při provádění DriverManager.getConnection(properties.getProperty("url"), properties);, protože soubor vlastností se předává jako argument.

Teď můžete tuto hlavní třídu spustit pomocí svého oblíbeného nástroje:

  • Pomocí integrovaného vývojového prostředí (IDE) můžete kliknout pravým tlačítkem na třídu DemoApplication a spustit ji.
  • Pomocí Mavenu můžete aplikaci spustit spuštěním příkazu: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".

Aplikace se připojí k Azure Database for PostgreSQL flexibilnímu serveru, vytvoří schéma databáze a pak připojení zavře, jak vidíte v protokolech konzoly:

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

Vytvoření doménové třídy

Vytvořte novou Todo třídu Java vedle DemoApplication třídy a přidejte následující kód:

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

Tato třída je doménový model mapovaný na todo tabulku, kterou jste vytvořili při provádění skriptu schema.sql .

Vložení dat do Služby Azure Database for PostgreSQL

Do souboru src/main/java/DemoApplication.java za hlavní metodu přidejte následující metodu pro vložení dat do databáze:

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

Teď můžete zrušit komentář ke dvěma následujícím řádkům main v metodě:

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

Při spuštění hlavní třídy by měl vytvořit následující výstup:

[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

Čtení dat z Azure Database for PostgreSQL

Pokud chcete ověřit, že váš kód funguje správně, přečtěte si data, která jste předtím vložili.

Do souboru src/main/java/DemoApplication.java za metodu insertData přidejte následující metodu pro čtení dat z databáze:

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

V metodě teď můžete odkomentovat následující řádek main

todo = readData(connection);

Při spuštění hlavní třídy by měl vytvořit následující výstup:

[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

Aktualizace dat v Azure Database for PostgreSQL

Pokud chcete data aktualizovat, postupujte následovně.

Stále v souboru src/main/java/DemoApplication.java přidejte za metodu readData následující metodu pro aktualizaci dat uvnitř databáze:

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

Teď můžete zrušit komentář ke dvěma následujícím řádkům main v metodě:

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

Při spuštění hlavní třídy by měl vytvořit následující výstup:

[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

Odstranění dat v Azure Database for PostgreSQL

Nakonec odstraňte data, která jste předtím vložili.

Stále v souboru src/main/java/DemoApplication.java přidejte za metodu updateData následující metodu pro odstranění dat uvnitř databáze:

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

V metodě teď můžete odkomentovat následující řádek main

deleteData(todo, connection);

Při spuštění hlavní třídy by měl vytvořit následující výstup:

[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

Vyčistěte zdroje

Vytvořili jste aplikaci Java, která k ukládání a načítání dat z flexibilního serveru Azure Database for PostgreSQL používá JDBC.

Pokud chcete vyčistit všechny prostředky použité během tohoto rychlého startu, odstraňte skupinu prostředků pomocí následujícího příkazu:

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

Související obsah

  • Last updated on