Udostępnij za pośrednictwem

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

  • Artykuł

DOTYCZY: Azure Database for PostgreSQL — serwer elastyczny

W tym artykule przedstawiono tworzenie przykładowej aplikacji, która używa języka Java i JDBC do przechowywania i pobierania informacji na serwerze elastycznym usługi 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 użyj następującego polecenia, aby skonfigurować niektóre zmienne środowiskowe.

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)

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

  • <YOUR_DATABASE_SERVER_NAME>: nazwa wystąpienia serwera elastycznego usługi Azure Database for PostgreSQL, które powinno być unikatowe na platformie Azure.
  • <YOUR_DATABASE_NAME>: nazwa bazy danych wystąpienia serwera elastycznego usługi Azure Database for PostgreSQL, która powinna być unikatowa na platformie Azure.
  • <YOUR_AZURE_REGION>: region świadczenia usługi Azure do użycia. 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 wystąpienia serwera elastycznego usługi Azure Database for 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

W przypadku ustawienia <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 serwera elastycznego usługi Azure Database for PostgreSQL

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

Tworzenie wystąpienia serwera elastycznego usługi Azure Database for PostgreSQL i konfigurowanie użytkownika administratora

Pierwszą rzeczą, którą tworzysz, jest zarządzane wystąpienie serwera elastycznego usługi Azure Database for PostgreSQL.

Uwaga

Więcej szczegółowych informacji na temat tworzenia wystąpień serwera elastycznego usługi Azure Database for PostgreSQL można znaleźć w temacie Create an Azure Database for PostgreSQL flexible server instance by using the Azure Portal (Tworzenie wystąpienia elastycznego 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

Uruchom następujące polecenie, aby utworzyć serwer:

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

Aby skonfigurować administratora firmy Microsoft Entra po utworzeniu serwera, wykonaj kroki opisane w temacie Zarządzanie rolami firmy Microsoft Entra w usłudze Azure Database for PostgreSQL — serwer elastyczny.

Ważne

Podczas konfigurowania administratora do bazy danych platformy Azure jest dodawany nowy użytkownik z pełnymi uprawnieniami administratora. Możesz utworzyć wielu administratorów usługi Microsoft Entra na wystąpienie serwera elastycznego usługi Azure Database for PostgreSQL.

Masz jakieś problemy? Daj nam znać.

Konfigurowanie reguły zapory dla wystąpienia serwera elastycznego usługi Azure Database for PostgreSQL

Wystąpienia serwera elastycznego 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 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

Jeśli łączysz się z wystąpieniem serwera elastycznego usługi Azure Database for 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 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

Konfigurowanie elastycznej bazy danych serwera usługi Azure Database for PostgreSQL

Utwórz nową bazę danych przy użyciu następującego polecenia:

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

Tworzenie elastycznego serwera usługi Azure Database for PostgreSQL, użytkownika niebędącego administratorem 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 zarządzania użytkownikami serwera elastycznego usługi Azure Database for PostgreSQL można znaleźć w temacie Zarządzanie użytkownikami usługi Microsoft Entra — Azure Database for PostgreSQL — serwer elastyczny.

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
select * from pgaadauth_create_principal('$AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME', false, false);
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 dbname=postgres 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 to apache Maven , który konfiguruje projekt do użycia:

  • Java 8
  • Najnowszy sterownik PostgreSQL dla języka Java

Przygotowywanie pliku konfiguracji do nawiązania połączenia z serwerem elastycznym usługi 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}
EOF

Uwaga

Właściwość url konfiguracji została ?serverTimezone=UTC dołączona, aby sterownik JDBC używał protokołu TLS (Transport Layer Security) podczas nawiązywania połączenia z bazą danych. Należy używać protokołu TLS z serwerem elastycznym usługi Azure Database for PostgreSQL i dobrym rozwiązaniem w zakresie zabezpieczeń.

Tworzenie pliku SQL w celu wygenerowania schematu bazy danych

Użyjesz pliku src/main/resources/schema.sql w celu utworzenia schematu bazy danych. Utwórz ten plik z następującą zawartością:

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

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 elastycznego wystąpienia serwera usługi Azure Database for PostgreSQL.

Utwórz plik src/main/java/DemoApplication.java i 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());
        }

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

Masz jakieś problemy? Daj nam znać.

Ten kod Java będzie używać pliku application.properties i schema.sql utworzonych wcześniej, w celu nawiązania połączenia z wystąpieniem serwera elastycznego usługi Azure Database for PostgreSQL i utworzenia schematu, który będzie przechowywać nasze dane.

W tym pliku widać, że skomentowaliśmy metody wstawiania, odczytywania, aktualizowania i usuwania danych: zakodujemy te metody w pozostałej części tego artykułu i będzie można usunąć komentarz po sobie.

Uwaga

Poświadczenia bazy danych są przechowywane we właściwościach użytkownika i hasła 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ę, wykonując polecenie: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".

Aplikacja powinna połączyć się z wystąpieniem serwera elastycznego usługi 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 elastycznego serwera 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 elastycznego serwera usługi Azure Database for PostgreSQL

Przeczytajmy wcześniej wstawione dane, aby sprawdzić, czy nasz kod działa poprawnie.

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 na serwerze elastycznym usługi Azure Database for PostgreSQL

Zaktualizujmy dane, które wcześniej wstawiliśmy.

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 na serwerze elastycznym usługi Azure Database for PostgreSQL

Na koniec usuńmy 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 serwera elastycznego 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