Migre para o Innovate Summit:
Saiba como migrar e modernizar para o Azure pode aumentar o desempenho, a resiliência e a segurança da sua empresa, permitindo que você adote totalmente a IA.Registe-se agora
Este browser já não é suportado.
Atualize para o Microsoft Edge para tirar partido das mais recentes funcionalidades, atualizações de segurança e de suporte técnico.
Usar Java e JDBC com o Banco de Dados do Azure para MySQL - Servidor Flexível
Artigo
Este artigo demonstra a criação de um aplicativo de exemplo que usa Java e JDBC para armazenar e recuperar informações no Banco de Dados do Azure para o Servidor Flexível MySQL.
JDBC é a API Java padrão para se conectar a bancos de dados relacionais tradicionais.
Neste artigo, incluiremos dois métodos de autenticação: autenticação Microsoft Entra e autenticação MySQL. A guia Sem senha mostra a autenticação do Microsoft Entra e a guia Senha mostra a autenticação do MySQL.
A autenticação do Microsoft Entra é um mecanismo para se conectar ao Banco de Dados do Azure para o Servidor Flexível MySQL usando identidades definidas na ID do Microsoft Entra. Com a autenticação do Microsoft Entra, você pode gerenciar identidades de usuário de banco de dados e outros serviços da Microsoft em um local central, o que simplifica o gerenciamento de permissões.
A autenticação MySQL usa contas armazenadas no MySQL. Se você optar por usar senhas como credenciais para as contas, essas credenciais serão armazenadas na user tabela. Como essas senhas são armazenadas no MySQL, você precisará gerenciar a rotação das senhas sozinho.
Azure Cloud Shell ou CLI do Azure. Recomendamos o Azure Cloud Shell para que possa iniciar sessão automaticamente e ter acesso a todas as ferramentas de que necessita.
Um Java Development Kit suportado, versão 8 (incluído no Azure Cloud Shell).
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)
Substitua os marcadores de posição pelos seguintes valores, que são utilizados ao longo deste artigo:
<YOUR_DATABASE_NAME>: O nome da sua instância do Banco de Dados do Azure para o Servidor Flexível MySQL, que deve ser exclusiva no Azure.
<YOUR_AZURE_REGION>: A região do Azure que você usará. Pode utilizar a região eastus por predefinição, mas recomendamos que configure uma região mais próxima do local onde vive. Você pode ver a lista completa de regiões disponíveis digitando az account list-locations.
<YOUR_USER_ASSIGNED_MANAGED_IDENTITY_NAME>: O nome do servidor de identidade gerenciado atribuído ao usuário, que deve ser exclusivo no Azure.
Substitua os marcadores de posição pelos seguintes valores, que são utilizados ao longo deste artigo:
<YOUR_DATABASE_NAME>: O nome da sua instância do Banco de Dados do Azure para o Servidor Flexível MySQL, que deve ser exclusiva no Azure.
<YOUR_AZURE_REGION>: A região do Azure que você usará. Pode utilizar a região eastus por predefinição, mas recomendamos que configure uma região mais próxima do local onde vive. Você pode ver a lista completa de regiões disponíveis digitando az account list-locations.
<YOUR_MYSQL_ADMIN_PASSWORD> e <YOUR_MYSQL_NON_ADMIN_PASSWORD>: A senha do seu servidor de banco de dados MySQL. Essa palavra-passe deve ter pelo menos oito carateres. Os caracteres devem ser de três das seguintes categorias: letras maiúsculas inglesas, letras minúsculas inglesas, números (0-9) e caracteres não alfanuméricos (!, $, #, % e assim por diante).
Depois, crie um grupo de recursos:
az group create \
--name $AZ_RESOURCE_GROUP \
--location $AZ_LOCATION \
--output tsv
Criar uma instância da Base de Dados do Azure para MySQL
Criar o Banco de Dados do Azure para a instância do Servidor Flexível MySQL e configurar um usuário administrador
A primeira coisa que você cria é um Banco de Dados do Azure gerenciado para a instância do Servidor Flexível MySQL.
Se estiver a utilizar a CLI do Azure, execute o seguinte comando para se certificar de que tem permissão suficiente:
az login --scope https://graph.microsoft.com/.default
Execute o seguinte comando para criar o servidor:
az mysql flexible-server create \
--resource-group $AZ_RESOURCE_GROUP \
--name $AZ_DATABASE_NAME \
--location $AZ_LOCATION \
--yes \
--output tsv
Execute o seguinte comando para criar uma identidade atribuída pelo usuário para atribuição:
az identity create \
--resource-group $AZ_RESOURCE_GROUP \
--name $AZ_USER_IDENTITY_NAME
Importante
Depois de criar a identidade atribuída pelo usuário, peça a um usuário com pelo menos a função de Administrador de Função Privilegiada para conceder as seguintes permissões para essa identidade gerenciada atribuída pelo usuário: User.Read.All, GroupMember.Read.Alle Application.Read.ALL. Como alternativa, dê à identidade gerenciada atribuída pelo usuário a função Leitores de diretório . Para obter mais informações, consulte a seção Permissões da autenticação do Microsoft Entra para o Banco de Dados do Azure para MySQL - Servidor Flexível.
Execute o seguinte comando para atribuir a identidade ao Banco de Dados do Azure para o Servidor Flexível MySQL para criar o administrador do Microsoft Entra:
az mysql flexible-server identity assign \
--resource-group $AZ_RESOURCE_GROUP \
--server-name $AZ_DATABASE_NAME \
--identity $AZ_USER_IDENTITY_NAME
Execute o seguinte comando para definir o usuário admin do 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
Importante
Ao definir o administrador, um novo usuário é adicionado ao Banco de Dados do Azure para instância do Servidor Flexível MySQL com permissões de administrador completas. Apenas um administrador do Microsoft Entra pode ser criado por instância do Banco de Dados do Azure para o Servidor Flexível MySQL e a seleção de outro substituirá o administrador existente do Microsoft Entra configurado para o servidor.
Este comando cria uma pequena instância do Banco de Dados do Azure para o Servidor Flexível MySQL e define o administrador do Ative Directory como o usuário conectado.
Configurar uma regra de firewall para sua instância do Banco de Dados do Azure para o Servidor Flexível MySQL
As instâncias do Banco de Dados do Azure para Servidor Flexível MySQL são protegidas por padrão. O serviço tem uma firewall que não permite ligações de entrada.
Você pode pular esta etapa se estiver usando o Bash porque o flexible-server create comando já detetou seu endereço IP local e o definiu no servidor MySQL.
Se você estiver se conectando à instância do Servidor Flexível do Banco de Dados do Azure para MySQL a partir do Subsistema Windows para Linux (WSL) em um computador Windows, precisará adicionar a ID do host WSL ao firewall. Obtenha o endereço IP da sua máquina host executando o seguinte comando no WSL:
sudo cat /etc/resolv.conf
Copie o endereço IP após o termo nameservere, em seguida, use o seguinte comando para definir uma variável de ambiente para o endereço IP WSL:
AZ_WSL_IP_ADDRESS=<the-copied-IP-address>
Em seguida, use o seguinte comando para abrir o firewall do servidor para seu aplicativo baseado em WSL:
Crie um script SQL chamado create_ad_user.sql para criar um usuário não administrador. Adicione o seguinte conteúdo e salve-o localmente:
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
Em seguida, use o seguinte comando para executar o script SQL para criar o usuário não administrador do Microsoft Entra:
Agora use o seguinte comando para remover o arquivo de script SQL temporário:
rm create_ad_user.sql
Crie um script SQL chamado create_user.sql para criar um usuário não administrador. Adicione o seguinte conteúdo e salve-o localmente:
cat << EOF > create_user.sql
CREATE USER '$AZ_MYSQL_NON_ADMIN_USERNAME'@'%' IDENTIFIED BY '$AZ_MYSQL_NON_ADMIN_PASSWORD';
GRANT ALL PRIVILEGES ON demo.* TO '$AZ_MYSQL_NON_ADMIN_USERNAME'@'%';
FLUSH PRIVILEGES;
EOF
Em seguida, use o seguinte comando para executar o script SQL para criar o usuário não administrador do Microsoft Entra:
mysql -h $AZ_DATABASE_NAME.mysql.database.azure.com --user $AZ_MYSQL_ADMIN_USERNAME --enable-cleartext-plugin --password=$AZ_MYSQL_ADMIN_PASSWORD < create_user.sql
Agora use o seguinte comando para remover o arquivo de script SQL temporário:
rm create_user.sql
Criar um novo projeto Java
Usando seu IDE favorito, crie um novo projeto Java e adicione um arquivo pom.xml em seu diretório raiz:
Preparar um arquivo de configuração para se conectar ao Banco de Dados do Azure para MySQL
Execute o seguinte script no diretório raiz do projeto para criar um arquivo src/main/resources/database.properties e adicionar detalhes de configuração:
Se você estiver usando a classe MysqlConnectionPoolDataSource como fonte de dados em seu aplicativo, remova "defaultAuthenticationPlugin=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin" na url.
A propriedade url configuration foi ?serverTimezone=UTC acrescentada para informar ao driver JDBC para usar o formato de data UTC (ou Tempo Universal Coordenado) ao se conectar ao banco de dados. Caso contrário, seu servidor Java não usaria o mesmo formato de data do banco de dados, o que resultaria em um erro.
Criar um arquivo SQL para gerar o esquema de banco de dados
Você usará um arquivo src/main/resources/schema.sql para criar um esquema de banco de dados. Crie esse arquivo, com o seguinte conteúdo:
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
Codificar a aplicação
Ligue-se à base de dados
Em seguida, adicione o código Java que usará JDBC para armazenar e recuperar dados do seu servidor MySQL.
Crie um arquivo src/main/java/DemoApplication.java e adicione o seguinte conteúdo:
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();
}
}
Esse código Java usará o database.properties e os arquivos de schema.sql que você criou anteriormente, para se conectar à instância do Servidor Flexível do Banco de Dados do Azure para MySQL e criar um esquema que armazenará seus dados.
Neste arquivo, você pode ver que comentamos métodos para inserir, ler, atualizar e excluir dados: você codificará esses métodos no restante deste artigo e poderá descomentá-los um após o outro.
Nota
As credenciais do banco de dados são armazenadas nas propriedades de usuário e senha do arquivo database.properties . Essas credenciais são usadas durante a execução DriverManager.getConnection(properties.getProperty("url"), properties);do , pois o arquivo de propriedades é passado como um argumento.
Nota
A AbandonedConnectionCleanupThread.uncheckedShutdown(); linha no final é um comando específico do driver MySQL para destruir um thread interno ao desligar o aplicativo.
Pode ser ignorado com segurança.
Agora você pode executar esta classe principal com sua ferramenta favorita:
Usando seu IDE, você deve ser capaz de clicar com o botão direito do mouse na classe DemoApplication e executá-la.
Usando o Maven, você pode executar o aplicativo executando: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".
O aplicativo deve se conectar ao Banco de Dados do Azure para a instância do Servidor Flexível MySQL, criar um esquema de banco de dados e fechar a conexão, como você deve ver nos logs do console:
Em seguida, leia os dados inseridos anteriormente para validar se o código funciona corretamente.
No arquivo src/main/java/DemoApplication.java, após o insertData método, adicione o seguinte método para ler dados do banco de dados:
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;
}
Agora você pode descomentar a seguinte linha no main método:
todo = readData(connection);
A execução da classe principal agora deve produzir a seguinte saída:
[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
Atualizar dados no Banco de Dados do Azure para o Servidor Flexível MySQL
Em seguida, atualize os dados inseridos anteriormente.
Ainda no arquivo src/main/java/DemoApplication.java , após o readData método, adicione o seguinte método para atualizar dados dentro do banco de dados:
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);
}
Agora você pode descomentar as duas linhas a main seguir no método:
todo.setDetails("congratulations, you have updated data!");
updateData(todo, connection);
A execução da classe principal agora deve produzir a seguinte saída:
[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
Excluir dados no Banco de Dados do Azure para o Servidor Flexível MySQL
Por fim, exclua os dados inseridos anteriormente.
Ainda no arquivo src/main/java/DemoApplication.java , após o updateData método, adicione o seguinte método para excluir dados dentro do banco de dados:
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);
}
Agora você pode descomentar a seguinte linha no main método:
deleteData(todo, connection);
A execução da classe principal agora deve produzir a seguinte saída:
[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
Clean up resources (Limpar recursos)
Parabéns! Você criou um aplicativo Java que usa JDBC para armazenar e recuperar dados do Banco de Dados do Azure para o Servidor Flexível MySQL.
Para limpar todos os recursos usados durante este início rápido, exclua o grupo de recursos usando o seguinte comando:
az group delete \
--name $AZ_RESOURCE_GROUP \
--yes
Administre uma infraestrutura de banco de dados SQL Server para bancos de dados relacionais na nuvem, locais e híbridos usando as ofertas de banco de dados relacional PaaS da Microsoft.