Szybki start: używanie języków Java i JDBC z usługą Azure Database for PostgreSQL

  • Artykuł

DOTYCZY: Azure Database for PostgreSQL — pojedynczy serwer

Ważne

Usługa Azure Database for PostgreSQL — pojedynczy serwer znajduje się na ścieżce wycofania. Zdecydowanie zalecamy uaktualnienie do usługi Azure Database for PostgreSQL — serwer elastyczny. Aby uzyskać więcej informacji na temat migracji do usługi Azure Database for PostgreSQL — serwer elastyczny, zobacz Co się dzieje z usługą Azure Database for PostgreSQL — pojedynczy serwer?.

W tym artykule pokazano, jak utworzyć przykładową aplikację, która używa języka Java i JDBC do przechowywania i pobierania informacji w usłudze Azure Database for PostgreSQL.

JDBC to standardowy interfejs API języka Java do łączenia się z tradycyjnymi relacyjnymi bazami danych.

W tym artykule uwzględnimy dwie metody uwierzytelniania: uwierzytelnianie firmy Microsoft Entra i uwierzytelnianie PostgreSQL. Karta Bez hasła zawiera uwierzytelnianie firmy Microsoft Entra, a karta Hasło zawiera uwierzytelnianie PostgreSQL.

Uwierzytelnianie entra firmy Microsoft to mechanizm nawiązywania połączenia z usługą Azure Database for PostgreSQL przy użyciu tożsamości zdefiniowanych w identyfikatorze Entra firmy Microsoft. Dzięki uwierzytelnieniu firmy Microsoft Entra można zarządzać tożsamościami użytkowników bazy danych i innymi usługi firmy Microsoft w centralnej lokalizacji, co upraszcza zarządzanie uprawnieniami.

Uwierzytelnianie postgreSQL używa kont przechowywanych w usłudze PostgreSQL. Jeśli zdecydujesz się używać haseł jako poświadczeń dla kont, te poświadczenia będą przechowywane w user tabeli. Ponieważ te hasła są przechowywane w usłudze PostgreSQL, musisz samodzielnie zarządzać rotacją haseł.

Wymagania wstępne

Przygotowywanie środowiska roboczego

Najpierw skonfiguruj niektóre zmienne środowiskowe. W usłudze Azure Cloud Shell uruchom następujące polecenia:

export AZ_RESOURCE_GROUP=database-workshop
export AZ_DATABASE_SERVER_NAME=<YOUR_DATABASE_SERVER_NAME>
export AZ_DATABASE_NAME=demo
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)
export CURRENT_USER_OBJECTID=$(az ad signed-in-user show --query id -o tsv)

Zastąp symbole zastępcze następującymi wartościami, które są używane w tym artykule:

  • <YOUR_DATABASE_SERVER_NAME>: nazwa serwera PostgreSQL, który powinien być unikatowy na platformie Azure.
  • <YOUR_AZURE_REGION>: region platformy Azure, którego będziesz używać. Możesz domyślnie zastosować region eastus, ale zalecamy skonfigurowanie regionu bliżej Twojego miejsca zamieszkania. Pełną listę dostępnych regionów można wyświetlić, wprowadzając polecenie az account list-locations.
  • <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>: nazwa użytkownika serwera bazy danych PostgreSQL. Upewnij się, że nazwa użytkownika jest prawidłowym użytkownikiem w dzierżawie firmy Microsoft Entra.
  • <YOUR_LOCAL_IP_ADDRESS>: adres IP komputera lokalnego, z którego będzie uruchamiana aplikacja Spring Boot. Jednym z wygodnych sposobów znalezienia go jest otwarcie whatismyip.akamai.com.

Ważne

Podczas ustawiania <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME> nazwa użytkownika musi już istnieć w dzierżawie firmy Microsoft Entra lub nie będzie można utworzyć użytkownika Microsoft Entra w bazie danych.

Następnie utwórz grupę zasobów przy użyciu następującego polecenia:

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

Tworzenie wystąpienia usługi Azure Database for PostgreSQL

W poniższych sekcjach opisano sposób tworzenia i konfigurowania wystąpienia bazy danych.

Tworzenie serwera PostgreSQL i konfigurowanie użytkownika administratora

Pierwszą rzeczą, którą utworzysz, jest zarządzany serwer PostgreSQL z użytkownikiem administratora.

Uwaga

Więcej szczegółowych informacji na temat tworzenia serwerów PostgreSQL można znaleźć w temacie Create an Azure Database for PostgreSQL server by using the Azure Portal (Tworzenie serwera usługi Azure Database for PostgreSQL przy użyciu witryny Azure Portal).

Jeśli używasz interfejsu wiersza polecenia platformy Azure, uruchom następujące polecenie, aby upewnić się, że ma wystarczające uprawnienia:

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

Następnie uruchom następujące polecenie, aby utworzyć serwer:

az postgres server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME \
    --location $AZ_LOCATION \
    --sku-name B_Gen5_1 \
    --storage-size 5120 \
    --output tsv

Teraz uruchom następujące polecenie, aby ustawić użytkownika administratora firmy Microsoft Entra:

az postgres server ad-admin create \
    --resource-group $AZ_RESOURCE_GROUP \
    --server-name $AZ_DATABASE_SERVER_NAME \
    --display-name $CURRENT_USERNAME \
    --object-id $CURRENT_USER_OBJECTID

Ważne

Podczas ustawiania administratora nowy użytkownik jest dodawany do serwera usługi Azure Database for PostgreSQL z pełnymi uprawnieniami administratora. Tylko jeden administrator firmy Microsoft Entra można utworzyć na serwer PostgreSQL, a wybór innego spowoduje zastąpienie istniejącego administratora firmy Microsoft Entra skonfigurowanego dla serwera.

To polecenie tworzy mały serwer PostgreSQL i ustawia administratora usługi Active Directory na zalogowanego użytkownika.

Konfigurowanie reguły zapory dla serwera PostgreSQL

Wystąpienia usługi Azure Database for PostgreSQL są domyślnie zabezpieczone. Ma ona zaporę, która nie zezwala na żadne połączenie przychodzące. Aby móc używać bazy danych, należy dodać regułę zapory, która umożliwi lokalnemu adresowi IP dostęp do serwera bazy danych.

Ponieważ na początku tego artykułu skonfigurowano lokalny adres IP, możesz otworzyć zaporę serwera, uruchamiając następujące polecenie:

az postgres server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME-database-allow-local-ip \
    --server $AZ_DATABASE_SERVER_NAME \
    --start-ip-address $AZ_LOCAL_IP_ADDRESS \
    --end-ip-address $AZ_LOCAL_IP_ADDRESS \
    --output tsv

Jeśli łączysz się z serwerem PostgreSQL z Podsystem Windows dla systemu Linux (WSL) na komputerze z systemem Windows, musisz dodać identyfikator hosta programu WSL do zapory.

Uzyskaj adres IP maszyny hosta, uruchamiając następujące polecenie w programie WSL:

cat /etc/resolv.conf

Skopiuj adres IP zgodnie z terminem nameserver, a następnie użyj następującego polecenia, aby ustawić zmienną środowiskową dla adresu IP WSL:

AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

Następnie użyj następującego polecenia, aby otworzyć zaporę serwera w aplikacji opartej na protokole WSL:

az postgres server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME-database-allow-local-ip \
    --server $AZ_DATABASE_SERVER_NAME \
    --start-ip-address $AZ_WSL_IP_ADDRESS \
    --end-ip-address $AZ_WSL_IP_ADDRESS \
    --output tsv

Konfigurowanie bazy danych PostgreSQL

Utworzony wcześniej serwer PostgreSQL jest pusty. Użyj następującego polecenia, aby utworzyć nową bazę danych.

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

Tworzenie użytkownika niebędącego administratorem bazy danych PostgreSQL i udzielanie uprawnień

Następnie utwórz użytkownika niebędącego administratorem i przyznaj wszystkie uprawnienia do bazy danych.

Uwaga

Więcej szczegółowych informacji na temat tworzenia użytkowników postgreSQL można znaleźć w temacie Tworzenie użytkowników w usłudze Azure Database for PostgreSQL.

Utwórz skrypt SQL o nazwie create_ad_user.sql na potrzeby tworzenia użytkownika niebędącego administratorem. Dodaj następującą zawartość i zapisz ją lokalnie:

cat << EOF > create_ad_user.sql
SET aad_validate_oids_in_tenant = off;
CREATE ROLE "$AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME" WITH LOGIN IN ROLE azure_ad_user;
GRANT ALL PRIVILEGES ON DATABASE $AZ_DATABASE_NAME TO "$AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME";
EOF

Następnie użyj następującego polecenia, aby uruchomić skrypt SQL w celu utworzenia użytkownika innego niż administrator firmy Microsoft:

psql "host=$AZ_DATABASE_SERVER_NAME.postgres.database.azure.com user=$CURRENT_USERNAME@$AZ_DATABASE_SERVER_NAME dbname=$AZ_DATABASE_NAME port=5432 password=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken) sslmode=require" < create_ad_user.sql

Teraz użyj następującego polecenia, aby usunąć tymczasowy plik skryptu SQL:

rm create_ad_user.sql

Tworzenie nowego projektu Java

Używając ulubionego środowiska IDE, utwórz nowy projekt Java przy użyciu języka Java 8 lub nowszego i dodaj plik pom.xml w katalogu głównym z następującą zawartością:

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

Ten plik jest plikiem Apache Maven , który konfiguruje projekt pod kątem używania języka Java 8 i ostatniego sterownika PostgreSQL dla języka Java.

Przygotowywanie pliku konfiguracji do nawiązania połączenia z usługą Azure Database for PostgreSQL

Utwórz plik src/main/resources/application.properties, a następnie dodaj następującą zawartość:

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}@${AZ_DATABASE_SERVER_NAME}
EOF

Uwaga

Właściwość url konfiguracji została ?sslmode=require dołączona, aby poinformować sterownik JDBC o użyciu protokołu TLS (Transport Layer Security) podczas nawiązywania połączenia z bazą danych. Używanie protokołu TLS jest obowiązkowe w usłudze Azure Database for PostgreSQL i jest dobrym rozwiązaniem w zakresie zabezpieczeń.

Tworzenie pliku SQL w celu wygenerowania schematu bazy danych

Do utworzenia schematu bazy danych użyjesz pliku src/main/resources/schema.sql . Utwórz ten plik, a następnie dodaj następującą zawartość:

cat << EOF > src/main/resources/schema.sql
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
EOF

Kodowanie aplikacji

Łączenie z bazą danych

Następnie dodaj kod Java, który będzie używać narzędzia JDBC do przechowywania i pobierania danych z serwera PostgreSQL.

Utwórz plik src/main/java/DemoApplication.java, a następnie dodaj następującą zawartość:

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

        /* Prepare for data processing in the PostgreSQL server.
        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();
    }
}

Ten kod Java będzie używać pliku application.properties i schema.sql plików utworzonych wcześniej w celu nawiązania połączenia z serwerem PostgreSQL i utworzenia schematu, który będzie przechowywać dane.

W tym pliku widać, że skomentowaliśmy metody wstawiania, odczytywania, aktualizowania i usuwania danych. Zakodujesz te metody w pozostałej części tego artykułu i będziesz mieć możliwość usunięcia komentarza po drugim.

Uwaga

Poświadczenia bazy danych są przechowywane we user właściwościach i password pliku application.properties. Te poświadczenia są używane podczas wykonywania DriverManager.getConnection(properties.getProperty("url"), properties);polecenia , ponieważ plik właściwości jest przekazywany jako argument.

Teraz możesz wykonać tę klasę główną za pomocą ulubionego narzędzia:

  • Za pomocą środowiska IDE powinno być możliwe kliknięcie prawym przyciskiem myszy klasy DemoApplication i wykonanie go.
  • Za pomocą narzędzia Maven możesz uruchomić aplikację przy użyciu następującego polecenia: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".

Aplikacja powinna nawiązać połączenie z usługą Azure Database for PostgreSQL, utworzyć schemat bazy danych, a następnie zamknąć połączenie, jak pokazano w dziennikach konsoli:

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

Tworzenie klasy domeny

Utwórz nową Todo klasę Java obok DemoApplication klasy i dodaj następujący kod:

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

Ta klasa jest modelem domeny zamapowanym na tabelę todo utworzoną podczas wykonywania skryptu schema.sql .

Wstawianie danych do usługi Azure Database for PostgreSQL

W pliku src/main/java/DemoApplication.java po metodzie main dodaj następującą metodę, aby wstawić dane do bazy danych:

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

Teraz możesz usunąć komentarz z dwóch następujących wierszy w metodzie main :

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

Wykonanie klasy głównej powinno teraz wygenerować następujące dane wyjściowe:

[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

Odczytywanie danych z usługi Azure Database for PostgreSQL

Aby sprawdzić, czy kod działa poprawnie, przeczytaj dane, które zostały wcześniej wstawione.

W pliku src/main/java/DemoApplication.java po metodzie insertData dodaj następującą metodę, aby odczytać dane z bazy danych:

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

Teraz możesz usunąć komentarz z następującego wiersza w metodzie main :

todo = readData(connection);

Wykonanie klasy głównej powinno teraz wygenerować następujące dane wyjściowe:

[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

Aktualizowanie danych w usłudze Azure Database for PostgreSQL

Następnie zaktualizuj wcześniej wstawione dane.

Nadal w pliku src/main/java/DemoApplication.java po metodzie readData dodaj następującą metodę, aby zaktualizować dane wewnątrz bazy danych:

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

Teraz możesz usunąć komentarz z dwóch następujących wierszy w metodzie main :

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

Wykonanie klasy głównej powinno teraz wygenerować następujące dane wyjściowe:

[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

Usuwanie danych w usłudze Azure Database for PostgreSQL

Na koniec usuń wcześniej wstawione dane.

Nadal w pliku src/main/java/DemoApplication.java po metodzie updateData dodaj następującą metodę, aby usunąć dane wewnątrz bazy danych:

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

Teraz możesz usunąć komentarz z następującego wiersza w metodzie main :

deleteData(todo, connection);

Wykonanie klasy głównej powinno teraz wygenerować następujące dane wyjściowe:

[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

Czyszczenie zasobów

Gratulacje! Utworzono aplikację Java, która używa narzędzia JDBC do przechowywania i pobierania danych z usługi Azure Database for PostgreSQL.

Aby wyczyścić wszystkie zasoby używane w tym przewodniku Szybki start, usuń grupę zasobów przy użyciu następującego polecenia:

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

Następne kroki

Migrowanie bazy danych przy użyciu funkcji eksportowania i importowania