Rychlý start: Použití Javy a JDBC s flexibilním serverem Azure Database for PostgreSQL

  • Článek

PLATÍ PRO: Flexibilní server Azure Database for PostgreSQL

Tento článek ukazuje vytvoření ukázkové aplikace, která k ukládání a načítání informací na flexibilním serveru Azure Database for PostgreSQL používá Javu a JDBC.

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

V tomto článku budeme obsahovat 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, budou tyto přihlašovací údaje uloženy v user tabulce. Vzhledem k tomu, že tato hesla jsou uložená v PostgreSQL, budete muset 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 instance flexibilního serveru Azure Database for PostgreSQL, který by měl být jedinečný v rámci Azure.
  • <YOUR_DATABASE_NAME>: Název databáze instance flexibilního serveru Azure Database for PostgreSQL, která by měla být jedinečná v rámci Azure.
  • <YOUR_AZURE_REGION>: Oblast Azure, která se má použít. Standardně můžete použít eastus, ale doporučujeme nakonfigurovat oblast blíže k místu, kde se nacházíte. Úplný seznam dostupných oblastí můžete zobrazit zadáním az account list-locations.
  • <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>: Uživatelské jméno instance flexibilního serveru Azure Database for PostgreSQL. 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 spustí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>musí uživatelské jméno již existovat ve vašem tenantovi Microsoft Entra nebo nebudete moci vytvořit uživatele Microsoft Entra ve vaší databázi.

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í instance flexibilního serveru Azure Database for PostgreSQL

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

Vytvoření instance flexibilního serveru Azure Database for PostgreSQL a nastavení uživatele správce

První věc, kterou vytvoříte, je spravovaná instance flexibilního serveru Azure Database for PostgreSQL.

Poznámka:

Podrobnější informace o vytváření instancí flexibilních serverů Azure Database for PostgreSQL najdete v tématu Vytvoření instance flexibilního serveru Azure Database for PostgreSQL pomocí webu Azure Portal.

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 na flexibilním serveru Azure Database for PostgreSQL.

Důležité

Při nastavování správce se nový uživatel s úplnými oprávněními správce přidá do databáze Azure Azure instance flexibilního serveru Azure Database for PostgreSQL. Pro instanci flexibilního serveru 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.

Konfigurace pravidla brány firewall pro instanci flexibilního serveru Azure Database for PostgreSQL

Instance flexibilního serveru Azure Database for PostgreSQL jsou ve výchozím nastavení zabezpečené. Obsahuje bránu firewall, která nepovoluje žádné příchozí připojení. Abyste mohli databázi používat, musíte přidat pravidlo brány firewall, které umožní přístup k databázovému serveru místní IP adresou.

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 připojujete k instanci flexibilního serveru Azure Database for PostgreSQL z Subsystém Windows pro Linux (WSL) na počítači s Windows, budete muset do brány firewall přidat ID hostitele WSL.

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

cat /etc/resolv.conf

Zkopírujte IP adresu za termínem nameservera 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

Konfigurace flexibilní serverové databáze 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í flexibilního serveru Azure Database for PostgreSQL bez oprávnění správce 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ě uživatelů flexibilního serveru Azure Database for PostgreSQL najdete v tématu Správa uživatelů Microsoft Entra – Azure Database for PostgreSQL – Flexibilní server.

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 uživatele Microsoft Entra 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

Teď 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í Javy 8 nebo novější a přidejte do kořenového adresáře soubor pom.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.3.6</version>
      </dependency>
      <dependency>
        <groupId>com.azure</groupId>
        <artifactId>azure-identity-extensions</artifactId>
        <version>1.0.0</version>
      </dependency>
    </dependencies>
</project>

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

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

Příprava konfiguračního souboru pro připojení k flexibilnímu serveru 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 konfigurace připojila ?serverTimezone=UTC ovladač JDBC, aby při připojování k databázi používal tls (Transport Layer Security). Je povinné používat protokol TLS s flexibilním serverem Azure Database for PostgreSQL a je to dobrý postup zabezpečení.

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

K vytvoření schématu databáze použijete soubor src/main/resources/schema.sql . Vytvořte tento soubor s následujícím obsahem:

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

Vytvoření kódu aplikace

Připojte se k databázi.

Dále přidejte kód Java, který bude používat JDBC k ukládání a načítání dat z instance 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 bude používat application.properties a soubory schema.sql , které jsme vytvořili dříve, aby se připojil k instanci flexibilního serveru Azure Database for PostgreSQL a vytvořil schéma, které bude ukládat naše data.

V tomto souboru vidíte, že jsme okomentovali metody pro vložení, čtení, aktualizaci a odstranění dat: tyto metody zakódujeme ve zbývající části tohoto článku a jeden po druhém je budete moct odkomentovat.

Poznámka:

Přihlašovací údaje databáze jsou uloženy ve vlastnostech uživatele a hesla souboru application.properties. Tyto přihlašovací údaje se používají 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) byste měli být schopni kliknout pravým tlačítkem myši 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 by se měla připojit k instanci flexibilního serveru Azure Database for PostgreSQL, vytvořit schéma databáze a pak připojení zavřít, jak byste měli vidět 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 flexibilního serveru 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);

Spuštění hlavní třídy by teď mělo 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 flexibilního serveru Azure Database for PostgreSQL

Pojďme si přečíst dříve vložená data, abychom ověřili, že náš kód funguje správně.

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

Spuštění hlavní třídy by teď mělo 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 na flexibilním serveru Azure Database for PostgreSQL

Pojďme aktualizovat data, která jsme předtím vložili.

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

Spuštění hlavní třídy by teď mělo 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 na flexibilním serveru Azure Database for PostgreSQL

Nakonec odstraníme data, která jsme vložili dříve.

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

Spuštění hlavní třídy by teď mělo 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čištění prostředků

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

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

Další kroky

Migrace vaší databáze pomocí exportu a importu