Udostępnij za pośrednictwem

Używanie języków Java i JDBC z usługą Azure Database for MySQL — serwer elastyczny

  • Artykuł

W tym artykule przedstawiono tworzenie przykładowej aplikacji korzystającej z języka Java i JDBC do przechowywania i pobierania informacji w usłudze Azure Database for MySQL — elastyczny serwer.

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 MySQL. Karta Bez hasła zawiera uwierzytelnianie firmy Microsoft Entra, a karta Hasło zawiera uwierzytelnianie MySQL.

Uwierzytelnianie entra firmy Microsoft to mechanizm łączenia się z serwerem elastycznym usługi Azure Database for MySQL 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 mySQL używa kont przechowywanych w usłudze MySQL. 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 MySQL, musisz samodzielnie zarządzać rotacją haseł.

Wymagania wstępne

  • Konto platformy Azure z aktywną subskrypcją.

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure. Obecnie za pomocą bezpłatnego konta platformy Azure możesz wypróbować usługę Azure Database for MySQL — serwer elastyczny bezpłatnie przez 12 miesięcy. Aby uzyskać więcej informacji, zobacz Używanie bezpłatnego konta platformy Azure do bezpłatnego wypróbowania usługi Azure Database for MySQL — serwer elastyczny bezpłatnie.

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_NAME=<YOUR_DATABASE_NAME>
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_MYSQL_AD_NON_ADMIN_USERNAME=demo-non-admin
export AZ_USER_IDENTITY_NAME=<YOUR_USER_ASSIGNED_MANAGED_IDENTITY_NAME>
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_NAME>: nazwa wystąpienia serwera elastycznego usługi Azure Database for MySQL, które powinno być unikatowe 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_USER_ASSIGNED_MANAGED_IDENTITY_NAME>: nazwa serwera tożsamości zarządzanej przypisanej przez użytkownika, która powinna być unikatowa na platformie Azure.

Następnie utwórz grupę zasobów:

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

Tworzenie wystąpienia usługi Azure Database for MySQL

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

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

Uwaga

Więcej szczegółowych informacji na temat tworzenia serwerów MySQL można znaleźć w przewodniku Szybki start: Tworzenie wystąpienia usługi Azure Database for MySQL za pomocą 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 mysql flexible-server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME \
    --location $AZ_LOCATION \
    --yes \
    --output tsv

Uruchom następujące polecenie, aby utworzyć tożsamość przypisaną przez użytkownika do przypisania:

az identity create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_USER_IDENTITY_NAME

Ważne

Po utworzeniu tożsamości przypisanej przez użytkownika poproś użytkownika o co najmniej rolę Administrator ról uprzywilejowanych, aby przyznać następujące uprawnienia dla tej tożsamości zarządzanej przypisanej przez użytkownika: User.Read.All, i .Application.Read.ALLGroupMember.Read.All Alternatywnie nadaj tożsamości zarządzanej przypisanej przez użytkownika rolę Czytelnicy katalogu. Aby uzyskać więcej informacji, zobacz sekcję Uprawnienia uwierzytelniania entra firmy Microsoft dla usługi Azure Database for MySQL — serwer elastyczny.

Uruchom następujące polecenie, aby przypisać tożsamość do usługi Azure Database for MySQL — serwer elastyczny na potrzeby tworzenia administratora firmy Microsoft Entra:

az mysql flexible-server identity assign \
    --resource-group $AZ_RESOURCE_GROUP \
    --server-name $AZ_DATABASE_NAME \
    --identity $AZ_USER_IDENTITY_NAME

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

az mysql flexible-server ad-admin create \
    --resource-group $AZ_RESOURCE_GROUP \
    --server-name $AZ_DATABASE_NAME \
    --display-name $CURRENT_USERNAME \
    --object-id $CURRENT_USER_OBJECTID \
    --identity $AZ_USER_IDENTITY_NAME

Ważne

Podczas ustawiania administratora nowy użytkownik zostanie dodany do wystąpienia serwera elastycznego usługi Azure Database for MySQL z pełnymi uprawnieniami administratora. Na wystąpienie serwera elastycznego usługi Azure Database for MySQL można utworzyć tylko jednego administratora entra firmy Microsoft, a wybór innego spowoduje zastąpienie istniejącego administratora firmy Microsoft Entra skonfigurowanego dla serwera.

To polecenie tworzy małe wystąpienie serwera elastycznego usługi Azure Database for MySQL i ustawia administratora usługi Active Directory na zalogowanego użytkownika.

Utworzone wystąpienie serwera elastycznego usługi Azure Database for MySQL ma pustą bazę danych o nazwie flexibleserverdb.

Masz jakieś problemy? Daj nam znać.

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

Wystąpienia serwera elastycznego usługi Azure Database for MySQL są domyślnie zabezpieczone. Ma ona zaporę, która nie zezwala na żadne połączenie przychodzące.

Jeśli używasz powłoki Bash, możesz pominąć ten krok, ponieważ flexible-server create polecenie już wykryło lokalny adres IP i ustawiło go na serwerze MySQL.

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

sudo 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 mysql flexible-server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME \
    --start-ip-address $AZ_WSL_IP_ADDRESS \
    --end-ip-address $AZ_WSL_IP_ADDRESS \
    --rule-name allowiprange \
    --output tsv

Konfigurowanie bazy danych MySQL

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

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

Tworzenie użytkownika innego niż administrator programu MySQL i udzielanie uprawnień

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

Uwaga

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

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:

export AZ_MYSQL_AD_NON_ADMIN_USERID=$(az ad signed-in-user show --query id --output tsv)

cat << EOF > create_ad_user.sql
SET aad_auth_validate_oids_in_tenant = OFF;

CREATE AADUSER '$AZ_MYSQL_AD_NON_ADMIN_USERNAME' IDENTIFIED BY '$AZ_MYSQL_AD_NON_ADMIN_USERID';

GRANT ALL PRIVILEGES ON demo.* TO '$AZ_MYSQL_AD_NON_ADMIN_USERNAME'@'%';

FLUSH privileges;

EOF

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

mysql -h $AZ_DATABASE_NAME.mysql.database.azure.com --user $CURRENT_USERNAME --enable-cleartext-plugin --password=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken) < 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 i dodaj plik pom.xml w katalogu głównym:

<?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>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</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 do użycia:

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

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

Uruchom następujący skrypt w katalogu głównym projektu, aby utworzyć plik src/main/resources/database.properties i dodać szczegóły konfiguracji:

mkdir -p src/main/resources && touch src/main/resources/database.properties

cat << EOF > src/main/resources/database.properties
url=jdbc:mysql://${AZ_DATABASE_NAME}.mysql.database.azure.com:3306/demo?sslMode=REQUIRED&serverTimezone=UTC&defaultAuthenticationPlugin=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin&authenticationPlugins=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin
user=${AZ_MYSQL_AD_NON_ADMIN_USERNAME}
EOF

Uwaga

Jeśli używasz klasy MysqlConnectionPoolDataSource jako źródła danych w aplikacji, usuń ciąg "defaultAuthenticationPlugin=com.azure.identitys.jdbc.mysql.AzureMysqlAuthenticationPlugin" w adresie URL.

mkdir -p src/main/resources && touch src/main/resources/database.properties

cat << EOF > src/main/resources/database.properties
url=jdbc:mysql://${AZ_DATABASE_NAME}.mysql.database.azure.com:3306/demo?sslMode=REQUIRED&serverTimezone=UTC&authenticationPlugins=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin
user=${AZ_MYSQL_AD_NON_ADMIN_USERNAME}
EOF

Uwaga

Właściwość url konfiguracji została ?serverTimezone=UTC dołączona, aby poinformować sterownik JDBC o użyciu formatu daty UTC (lub uniwersalnego czasu koordynowanego) podczas nawiązywania połączenia z bazą danych. W przeciwnym razie serwer Java nie będzie używać tego samego formatu daty co baza danych, co spowodowałoby błąd.

Tworzenie pliku SQL w celu wygenerowania schematu bazy danych

Aby utworzyć schemat bazy danych, użyjesz pliku src/main/resources/schema.sql . 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 serwera MySQL.

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

package com.example.demo;

import com.mysql.cj.jdbc.AbandonedConnectionCleanupThread;

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("database.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();
        AbandonedConnectionCleanupThread.uncheckedShutdown();
    }
}

Masz jakieś problemy? Daj nam znać.

Ten kod Java będzie używać pliku database.properties i plików schema.sql utworzonych wcześniej, w celu nawiązania połączenia z wystąpieniem serwera elastycznego usługi Azure Database for MySQL 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 w stanie usunąć ich komentarz po sobie.

Uwaga

Poświadczenia bazy danych są przechowywane we właściwościach użytkownika i hasła pliku database.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.

Uwaga

Wiersz AbandonedConnectionCleanupThread.uncheckedShutdown(); na końcu to polecenie specyficzne dla sterownika MySQL, aby zniszczyć wątek wewnętrzny podczas zamykania aplikacji. Można go bezpiecznie zignorować.

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 MySQL, 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 MySQL

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 MySQL

Następnie przeczytaj dane wstawione wcześniej, aby sprawdzić, czy 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

Masz jakieś problemy? Daj nam znać.

Aktualizowanie danych na serwerze elastycznym usługi Azure Database for MySQL

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

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 serwera elastycznego usługi Azure Database for MySQL.

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ępny krok

Migrowanie bazy danych MySQL do usługi Azure Database for MySQL przy użyciu zrzutu i przywracania