Partager via

Démarrage rapide : Utiliser Java et JDBC avec Azure Database pour MySQL

  • Article

S’APPLIQUE À : Azure Database pour MySQL - Serveur unique

Important

Le serveur unique Azure Database pour MySQL est en voie de mise hors service. Nous vous conseillons vivement de procéder à une mise à niveau vers Azure Database pour MySQL – Serveur flexible. Pour obtenir plus d’informations sur la migration vers Azure Database pour MySQL – Serveur flexible, consultez Qu’en est-il du Serveur unique Azure Database pour MySQL ?

Cette article montre la création d’un exemple d’application qui utilise Java et JDBC pour stocker et récupérer des informations dans Azure Database pour MySQL.

JDBC est l’API Java standard pour se connecter à des bases de données relationnelles classiques.

Dans cet article, nous inclurons deux méthodes d’authentification : l’authentification Microsoft Entra et l’authentification MySQL. L’onglet Sans mot de passe affiche l’authentification Microsoft Entra et l’onglet Mot de passe l’authentification MySQL.

L’authentification Microsoft Entra est un mécanisme de connexion à Azure Database pour MySQL à l’aide des identités définies dans Microsoft Entra ID. Avec l’authentification Microsoft Entra, vous pouvez gérer les identités des utilisateurs de base de données et d’autres services Microsoft dans un emplacement centralisé, ce qui simplifie la gestion des autorisations.

L’authentification MySQL utilise des comptes stockés dans MySQL. Si vous choisissez d’utiliser des mots de passe comme informations d’identification pour les comptes, ces informations d’identification sont stockées dans la table user. Comme ces mots de passe sont stockés dans MySQL, vous devez gérer vous-même la rotation des mots de passe.

Prérequis

  • Un compte Azure. Si vous n’en avez pas, inscrivez-vous pour un essai gratuit.
  • Azure Cloud Shell ou Azure CLI. Nous vous recommandons d’utiliser Azure Cloud Shell. Vous serez ainsi connecté automatiquement et vous aurez accès à tous les outils dont vous avez besoin.
  • Un Java Development Kit pris en charge, version 8 (inclus dans Azure Cloud Shell).
  • L’outil de build Apache Maven.
  • Client en ligne de commande MySQL. Vous pouvez vous connecter à votre serveur en utilisant l’outil en ligne de commande mysql.exe avec Azure Cloud Shell. Vous pouvez aussi utiliser la ligne de commande de mysql dans votre environnement local.

Préparer l’environnement de travail

Tout d’abord, configurez quelques variables d’environnement. Dans Azure Cloud Shell, exécutez les commandes suivantes :

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_MYSQL_AD_NON_ADMIN_USERNAME=demo-non-admin
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)

Remplacez les espaces réservés par les valeurs suivantes, qui sont utilisées dans cet article :

  • <YOUR_DATABASE_SERVER_NAME> : nom de votre serveur MySQL, qui doit être unique dans Azure.
  • <YOUR_AZURE_REGION>: région Azure que vous allez utiliser. Vous pouvez utiliser eastus par défaut, mais nous vous recommandons de configurer une région plus proche de l’endroit où vous vivez. Vous pouvez voir la liste complète des régions disponibles en entrant az account list-locations.
  • <YOUR_LOCAL_IP_ADDRESS>: adresse IP de votre ordinateur local, à partir duquel vous exécuterez votre application. Un moyen pratique de le trouver est d’ouvrir whatismyip.akamai.com.

Ensuite, créez un groupe de ressources à l’aide de la commande suivante :

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

Créer une instance Azure Database pour MySQL

Créer un serveur MySQL et configurer un utilisateur administrateur

La première chose que vous allez créer est un serveur MySQL managé.

Notes

Vous trouverez des informations plus détaillées sur la création de serveurs MySQL dans Démarrage rapide : Créer un serveur Azure Database pour MySQL en utilisant le portail Azure.

Si vous utilisez Azure CLI, exécutez la commande suivante pour vous assurer de disposer d’une autorisation suffisante :

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

Exécutez ensuite la commande suivante pour créer le serveur :

az mysql 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

Ensuite, exécutez la commande suivante pour définir l’utilisateur administrateur Microsoft Entra :

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

Important

Lorsque vous définissez l’administrateur, un nouvel utilisateur est ajouté au serveur Azure Database pour MySQL avec toutes les autorisations d’administrateur. Vous ne pouvez créer qu’un seul administrateur Microsoft Entra par serveur MySQL. La sélection d’un autre utilisateur entraîne le remplacement de l’administrateur Microsoft Entra existant configuré pour le serveur.

Cette commande crée un petit serveur MySQL et définit l’administrateur Active Directory sur l’utilisateur connecté.

Configurer une règle de pare-feu pour votre serveur MySQL

Les instances Azure Database pour MySQL sont sécurisées par défaut. Ces instances ont un pare-feu qui n’autorise aucune connexion entrante. Pour pouvoir utiliser notre base de données, vous devez ajouter une règle de pare-feu qui permet à l’adresse IP locale d’accéder au serveur de base de données.

Comme vous avez configuré votre adresse IP locale au début de cet article, vous pouvez ouvrir le pare-feu du serveur en exécutant la commande suivante :

az mysql 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

Si vous vous connectez à votre serveur MySQL à partir du Sous-système Windows pour Linux (WSL) sur un ordinateur Windows, vous devez ajouter l’ID d’hôte WSL à votre pare-feu.

Obtenez l’adresse IP de votre ordinateur hôte en exécutant la commande suivante dans WSL :

cat /etc/resolv.conf

Copiez l’adresse IP suivant le terme nameserver, puis utilisez la commande suivante pour définir une variable d’environnement pour l’adresse IP de WSL :

AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

Ensuite, utilisez la commande suivante pour ouvrir le pare-feu du serveur sur votre application WSL :

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

Configurer une base de données MySQL

Le serveur MySQL que vous avez créé précédemment est vide. Créez une base de données avec la commande suivante.

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

Créer un utilisateur non-administrateur MySQL et accorder des autorisations

Ensuite, créez un utilisateur non-administrateur et accordez toutes les autorisations sur la base de données.

Notes

Vous pouvez lire des informations plus détaillées sur la création d’utilisateurs MySQL dans Créer des utilisateurs dans Azure Database pour MySQL.

Créez un script SQL appelé create_ad_user.sql pour créer un utilisateur non administrateur. Ajoutez le contenu suivant et enregistrez-le localement :

export AZ_MYSQL_AD_NON_ADMIN_USERID=$CURRENT_USER_OBJECTID

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 $AZ_DATABASE_NAME.* TO '$AZ_MYSQL_AD_NON_ADMIN_USERNAME'@'%';

FLUSH privileges;

EOF

Utilisez ensuite la commande suivante pour exécuter le script SQL pour créer l’utilisateur non administrateur Microsoft Entra :

mysql -h $AZ_DATABASE_SERVER_NAME.mysql.database.azure.com --user $CURRENT_USERNAME@$AZ_DATABASE_SERVER_NAME --enable-cleartext-plugin --password=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken) < create_ad_user.sql

Utilisez maintenant la commande suivante pour supprimer le fichier de script SQL temporaire :

rm create_ad_user.sql

Créer un projet Java

En utilisant votre IDE préféré, créez un projet Java en utilisant Java 8 ou ultérieur. Créez un fichier pom.xml dans son répertoire racine et ajoutez le contenu suivant :

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

Ce fichier est un fichier Apache Maven qui configure votre projet pour utiliser Java 8 et un pilote MySQL récent pour Java.

Préparer un fichier de configuration pour se connecter à Azure Database pour MySQL

Exécutez le script suivant dans le répertoire racine du projet pour créer un fichier src/main/resources/database.properties et ajoutez des détails de configuration :

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

cat << EOF > src/main/resources/database.properties
url=jdbc:mysql://${AZ_DATABASE_SERVER_NAME}.mysql.database.azure.com:3306/${AZ_DATABASE_NAME}?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}@${AZ_DATABASE_SERVER_NAME}
EOF

Notes

Si vous utilisez la classe MysqlConnectionPoolDataSource comme source de données dans votre application, supprimez « defaultAuthenticationPlugin=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin » dans l’URL.

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

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

Notes

?serverTimezone=UTC a été ajouté à la propriété de configuration url pour indiquer au pilote JDBC d’utiliser le format de date UTC (Coordinated Universal Time) lors de la connexion à la base de données. Sans cela, votre serveur Java n’utiliserait pas le même format de date que la base de données, ce qui entraînerait une erreur.

Créer un fichier SQL pour générer le schéma de base de données

Ensuite, vous allez utiliser un fichier src/main/resources/schema.sql pour créer un schéma de base de données. Créez ce fichier et ajoutez le contenu suivant :

touch src/main/resources/schema.sql

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

Coder l’application

Se connecter à la base de données

Ensuite, ajoutez le code Java qui utilisera JDBC pour stocker et récupérer des données à partir de votre serveur MySQL.

Créez un fichier src/main/java/DemoApplication.java, puis ajoutez le contenu suivant :

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

        /* Prepare to store and retrieve data from the MySQL 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();
        AbandonedConnectionCleanupThread.uncheckedShutdown();
    }
}

Ce code Java utilise les fichiers database.properties et schema.sql que vous avez créés précédemment. Après vous être connecté au serveur MySQL, vous pouvez créer un schéma pour stocker vos données.

Dans ce fichier, vous pouvez voir que nous avons commenté les méthodes pour insérer, lire, mettre à jour et supprimer des données. Vous allez implémenter ces méthodes dans le reste de cet article, et vous pourrez les décommenter l’une après l’autre.

Notes

Les informations d’identification de base de données sont stockées dans les propriétés user et password du fichier database.properties. Ces informations d’identification sont utilisées lors de l’exécution de DriverManager.getConnection(properties.getProperty("url"), properties);, car le fichier de propriétés est passé comme argument.

Notes

La ligne AbandonedConnectionCleanupThread.uncheckedShutdown(); à la fin est une commande du pilote MySQL pour détruire un thread interne lors de l’arrêt de l’application. Vous pouvez sans problème ignorer cette ligne.

Vous pouvez maintenant exécuter cette classe main avec votre outil favori :

  • Avec votre IDE, vous devez être en mesure de cliquer avec le bouton droit sur la classe DemoApplication et de l’exécuter.
  • En utilisant Maven, vous pouvez exécuter l’application avec la commande suivante : mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".

L’application doit se connecter à Azure Database pour MySQL, créer un schéma de base de données, puis fermer la connexion. Vous devez voir une sortie similaire à l’exemple suivant dans les journaux de la console :

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

Créer une classe de domaine

Créez une classe Java Todo parallèlement à la classe DemoApplication, puis ajoutez le code suivant :

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

Cette classe est un modèle de domaine mappé sur la table todo que vous avez créée lors de l’exécution du script schema.sql.

Insertion des données dans Azure Database pour MySQL

Dans le fichier src/main/java/DemoApplication.java, après la méthode main, ajoutez la méthode suivante pour insérer des données dans la base de données :

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

Vous pouvez maintenant supprimer les marques de commentaire des deux lignes suivantes dans la méthode main :

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

L’exécution de la classe main doit maintenant produire la sortie suivante :

[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

Lecture des données depuis Azure Database pour MySQL

Ensuite, lisez les données que vous avez précédemment insérées pour vérifier le bon fonctionnement de votre code.

Dans le fichier src/main/java/DemoApplication.java, après la méthode insertData, ajoutez la méthode suivante pour lire des données de la base de données :

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

Vous pouvez maintenant supprimer les marques de commentaire de la ligne suivante dans la méthode main :

todo = readData(connection);

L’exécution de la classe main doit maintenant produire la sortie suivante :

[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

Mise à jour des données dans Azure Database pour MySQL

Ensuite, mettez à jour les données que vous avez insérées précédemment.

Toujours dans le fichier src/main/java/DemoApplication.java, après la méthode readData, ajoutez la méthode suivante pour mettre à jour des données dans la base de données :

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

Vous pouvez maintenant supprimer les marques de commentaire des deux lignes suivantes dans la méthode main :

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

L’exécution de la classe main doit maintenant produire la sortie suivante :

[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

Suppression des données dans Azure Database pour MySQL

Enfin, supprimez les données que vous avez insérées précédemment.

Toujours dans le fichier src/main/java/DemoApplication.java, après la méthode updateData, ajoutez la méthode suivante pour supprimer des données dans la base de données :

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

Vous pouvez maintenant supprimer les marques de commentaire de la ligne suivante dans la méthode main :

deleteData(todo, connection);

L’exécution de la classe main doit maintenant produire la sortie suivante :

[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

Nettoyer les ressources

Félicitations ! Vous avez créé une application Java qui utilise JDBC pour stocker et récupérer des données dans Azure Database pour MySQL.

Pour nettoyer toutes les ressources utilisées dans le cadre de ce guide de démarrage rapide, supprimez le groupe de ressources à l’aide de la commande suivante :

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

Étapes suivantes

Migrer une base de données MySQL vers une base de données Azure pour MySQL à l’aide des images mémoire et de la restauration