Início rápido: Utilizar Java e JDBC no Base de Dados do Azure para PostgreSQL – servidor flexível

Este artigo mostra como criar uma aplicação de exemplo que utiliza Java e JDBC para armazenar e recuperar informação no Base de Dados do Azure para PostgreSQL.

JDBC é a API padrão Java para ligação a bases de dados relacionais tradicionais.

Este artigo inclui dois métodos de autenticação: autenticação Microsoft Entra e autenticação PostgreSQL. A guia Sem senha mostra a autenticação do Microsoft Entra e a guia Senha mostra a autenticação do PostgreSQL.

A autenticação do Microsoft Entra é um mecanismo para se conectar ao Banco de Dados do Azure para PostgreSQL usando identidades definidas na ID do Microsoft Entra. Ao utilizar a autenticação Microsoft Entra, pode gerir as identidades dos utilizadores da base de dados e outros serviços serviços Microsoft numa localização central, o que simplifica a gestão de permissões.

A autenticação do PostgreSQL usa contas armazenadas no PostgreSQL. Se optar por usar palavras-passe como credenciais para as contas, armazene essas credenciais na user tabela. Como estas palavras-passe estão armazenadas no PostgreSQL, tens de gerir tu próprio a rotação das palavras-passe.

Pré-requisitos

Preparar o ambiente de trabalho

Primeiro, use o seguinte comando para configurar algumas variáveis de ambiente.

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)

Substitua os placeholders pelos seguintes valores, que são usados ao longo deste artigo.

  • <YOUR_DATABASE_SERVER_NAME>: O nome do seu servidor flexível Base de Dados do Azure para PostgreSQL, que deve ser único no Azure.
  • <YOUR_DATABASE_NAME>: O nome da base de dados do servidor flexível Base de Dados do Azure para PostgreSQL, que deve ser único dentro do Azure.
  • <YOUR_AZURE_REGION>: A região do Azure a ser usada. Podes usar eastus por defeito, mas escolhe uma região mais próxima de onde vives. Para ver a lista completa de regiões disponíveis, digite az account list-locations.
  • <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>: O nome de utilizador para o seu servidor flexível Base de Dados do Azure para PostgreSQL. Certifique-se de que o nome de utilizador é válido no seu tenant Microsoft Entra.
  • <YOUR_LOCAL_IP_ADDRESS>: O endereço IP do seu computador local, a partir do qual executa a sua aplicação Spring Boot. Uma maneira conveniente de encontrá-lo é abrir whatismyip.akamai.com.

Importante

Ao definir <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>, o utilizador deve já existir no seu tenant Microsoft Entra, caso contrário não pode criar um utilizador Microsoft Entra na sua base de dados.

Em seguida, crie um grupo de recursos usando o seguinte comando:

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

Crie um servidor flexível

As seções a seguir descrevem como criar e configurar sua instância de banco de dados.

Criar um servidor flexível e configurar o utilizador administrador

Observação

Para informações mais detalhadas sobre a criação do Base de Dados do Azure para PostgreSQL flexible servers, consulte Quickstart: Criar um servidor flexível Base de Dados do Azure para PostgreSQL.

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 postgres flexible-server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME \
    --location $AZ_LOCATION \
    --yes \
    --output tsv

Para configurar um administrador do Microsoft Entra depois de criar o servidor, siga as etapas em Gerenciar funções do Microsoft Entra no Banco de Dados do Azure para PostgreSQL.

Importante

Quando configura um administrador, adiciona um novo utilizador com privilégios completos de administrador à base de dados Azure do servidor flexível Base de Dados do Azure para PostgreSQL. Pode criar vários administradores do Microsoft Entra em cada servidor flexível do Base de Dados do Azure para PostgreSQL.

Tem algum problema? Deixe-nos saber.

Configurar uma regra de firewall para sua instância do Banco de Dados do Azure para PostgreSQL

Os servidores flexíveis do Base de Dados do Azure para PostgreSQL são seguros por defeito. Eles têm um firewall que bloqueia todas as ligações de entrada. Para usar a sua base de dados, adicione uma regra de firewall que conceda ao seu endereço IP local acesso ao servidor da base de dados.

Como você configurou seu endereço IP local no início deste artigo, você pode abrir o firewall do servidor executando o seguinte comando:

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

Se estiver a ligar-se ao seu servidor flexível Base de Dados do Azure para PostgreSQL a partir do Subsistema Windows para Linux (WSL) num computador Windows, precisa de adicionar o ID do host WSL ao seu firewall.

Obtenha o endereço IP da sua máquina anfitriã executando o seguinte comando em WSL:

cat /etc/resolv.conf

Copie o endereço IP que se segue ao termo nameserver, e depois 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:

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

Configurar um Banco de Dados do Azure para banco de dados PostgreSQL

Crie um novo banco de dados usando o seguinte comando:

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

Criar um Banco de Dados do Azure para usuário não administrador do PostgreSQL e conceder permissão

Em seguida, crie um usuário não administrador e conceda todas as permissões ao banco de dados.

Observação

Para obter informações mais detalhadas sobre como gerir os utilizadores do Base de Dados do Azure para PostgreSQL, consulte Gerir funções Microsoft Entra no Base de Dados do Azure para PostgreSQL.

Cria um script SQL chamado create_ad_user.sql para criar um utilizador não administrativo. Adicione o seguinte conteúdo e salve-o localmente:

cat << EOF > create_ad_user.sql
select * from pgaadauth_create_principal('$AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME', false, false);
EOF

Depois, use o seguinte comando para executar o script SQL e criar o utilizador não administrador da Microsoft Entra:

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

Use o seguinte comando para remover o ficheiro temporário de script SQL:

rm create_ad_user.sql

Criar um novo projeto Java

Usando o seu IDE favorito, crie um novo projeto Java usando Java 8 ou posterior. Adicione um ficheiropom.xml na pasta raiz com o seguinte conteúdo:

<?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.7.5</version>
      </dependency>
      <dependency>
        <groupId>com.azure</groupId>
        <artifactId>azure-identity-extensions</artifactId>
        <version>1.2.0</version>
      </dependency>
    </dependencies>
</project>

Este arquivo é um arquivo Apache Maven que configura seu projeto para usar:

  • Java 8
  • Um driver PostgreSQL recente para Java

Preparar um arquivo de configuração para se conectar ao Banco de Dados do Azure para PostgreSQL

Crie um ficheiro src/main/resources/application.properties e adicione o seguinte conteúdo:

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

Observação

A propriedade de configuração url inclui ?sslmode=require para garantir que o driver JDBC use TLS (Transport Layer Security) ao conectar-se à base de dados. O uso do TLS é obrigatório com o Base de Dados do Azure para PostgreSQL para servidores flexíveis e é uma prática de segurança recomendada.

Criar um arquivo SQL para gerar o esquema de banco de dados

Usa um ficheiro src/main/resources/schema.sql para criar um esquema de base de dados. Crie esse ficheiro e adicione 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

As secções seguintes explicam a escrita do código Java que se liga à base de dados, define um modelo de dados e executa operações básicas de CRUD.

Conectar-se ao banco de dados

De seguida, adicione o código Java que usa JDBC para armazenar e recuperar dados do seu servidor flexível Base de Dados do Azure para PostgreSQL.

Crie um arquivo src/main/java/DemoApplication.java e adicione o seguinte conteúdo:

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

Tem algum problema? Deixe-nos saber.

Este Java código usa o application.properties e os ficheiros schema.sql que criaste anteriormente para se ligar ao servidor flexível Base de Dados do Azure para PostgreSQL e criar um esquema que armazena os dados.

Neste ficheiro, os métodos para inserir, ler, atualizar e eliminar dados são comentados. O resto deste artigo explica a codificação desses métodos, e podes descompô-los um após o outro.

Observação

As credenciais do banco de dados são armazenadas nas propriedades de usuário e senha do arquivo application.properties . O código utiliza essas credenciais ao executar DriverManager.getConnection(properties.getProperty("url"), properties);, pois o ficheiro de propriedades é passado como argumento.

Agora você pode executar esta classe principal com sua ferramenta favorita:

  • Usando o seu IDE, pode clicar com o botão direito na classe DemoApplication e executá-la.
  • Usando o Maven, você pode executar o aplicativo executando: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".

A aplicação liga-se ao servidor flexível Base de Dados do Azure para PostgreSQL, cria um esquema de base de dados e depois fecha a ligação, como vê nos registos da consola:

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

Criar uma classe de domínio

Crie uma nova Todo classe Java ao lado da DemoApplication classe e adicione o seguinte código:

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

Esta classe é um modelo de domínio mapeado para a todo tabela que criaste ao executar o script schema.sql .

Inserir dados no Banco de Dados do Azure para PostgreSQL

No arquivo src/main/java/DemoApplication.java, após o método principal, adicione o seguinte método para inserir dados no banco de dados:

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

Agora pode descomentar as duas linhas seguintes no método main.

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

Quando executa a classe principal, ela deve produzir o seguinte resultado:

[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

Ler dados do Base de Dados do Azure para PostgreSQL

Para validar que o seu código funciona corretamente, leia os dados que inseriu anteriormente.

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

Quando executa a classe principal, ela deve produzir o seguinte resultado:

[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 Base de Dados do Azure para PostgreSQL

Para atualizar os dados, utilize os seguintes passos.

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 pode descomentar as duas linhas seguintes no método main.

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

Quando executa a classe principal, ela deve produzir o seguinte resultado:

[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

Eliminar dados no Base de Dados do Azure para PostgreSQL

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

Quando executa a classe principal, ela deve produzir o seguinte resultado:

[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

Limpeza de recursos

Criaste uma aplicação Java que usa JDBC para armazenar e recuperar dados de um servidor flexível Base de Dados do Azure para PostgreSQL.

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

Conteúdo relacionado

  • Last updated on