Inicio rápido: Usar Java y JDBC con Azure Database for PostgreSQL flexible server

En este artículo se muestra cómo crear una aplicación de ejemplo que usa Java y JDBC para almacenar y recuperar información en Azure Database for PostgreSQL.

JDBC es la API Java estándar para conectarse a bases de datos relacionales tradicionales.

En este artículo se incluyen dos métodos de autenticación: Microsoft Entra autenticación y autenticación de PostgreSQL. La pestaña Sin contraseña muestra la autenticación de Microsoft Entra y la pestaña Contraseña muestra la autenticación de PostgreSQL.

La autenticación de Microsoft Entra es un mecanismo de conexión a Azure Database for PostgreSQL mediante identidades definidas en Microsoft Entra ID. Mediante la autenticación Microsoft Entra, puede administrar identidades de usuario de base de datos y otros servicios Microsoft en una ubicación central, lo que simplifica la administración de permisos.

La autenticación de PostgreSQL usa cuentas almacenadas en PostgreSQL. Si decide usar contraseñas como credenciales para las cuentas, almacene estas credenciales en la user tabla. Dado que estas contraseñas se almacenan en PostgreSQL, debe administrar la rotación de las contraseñas usted mismo.

Prerrequisitos

Preparación del entorno de trabajo

En primer lugar, use el siguiente comando para configurar algunas variables de entorno.

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)

Reemplace los marcadores de posición por los siguientes valores, que se usan en este artículo:

  • <YOUR_DATABASE_SERVER_NAME>: el nombre del servidor flexible de Azure Database for PostgreSQL, que debe ser único en Azure.
  • <YOUR_DATABASE_NAME>: El nombre de la base de datos del servidor flexible de Azure Database for PostgreSQL, que debe ser único dentro de Azure.
  • <YOUR_AZURE_REGION>: región de Azure que se va a usar. Puede usar eastus de forma predeterminada, pero elija una región más cercana a la ubicación en la que vive. Para ver la lista completa de las regiones disponibles, escriba az account list-locations.
  • <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>: El nombre de usuario de su servidor flexible de Azure Database for PostgreSQL. Asegúrese de que el nombre de usuario sea válido en su tenant de Microsoft Entra.
  • <YOUR_LOCAL_IP_ADDRESS>: la dirección IP del equipo local, desde la que se ejecuta la aplicación de Spring Boot. Una manera cómoda de encontrarlo es abrir whatismyip.akamai.com.

Importante

Al establecer <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>, el usuario ya debe existir en su arrendatario de Microsoft Entra; de lo contrario, no podrá crear un usuario de Microsoft Entra en su base de datos.

A continuación, cree un grupo de recursos con el siguiente comando:

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

Creación de un servidor flexible

En las secciones siguientes se describe cómo crear y configurar una instancia de base de datos.

Creación de un servidor flexible y configuración de un usuario administrador

Nota:

Para obtener información más detallada sobre cómo crear servidores flexibles Azure Database for PostgreSQL, consulte Inicio rápido: Creación de un servidor flexible de Azure Database for PostgreSQL.

Si usa la CLI de Azure, ejecute el siguiente comando para asegurarse de que tiene permisos suficientes:

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

Ejecute el siguiente comando para crear el servidor:

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

Para configurar un administrador de Microsoft Entra después de crear el servidor, siga los pasos descritos en Administración de roles de Microsoft Entra en Azure Database for PostgreSQL.

Importante

Al configurar un administrador, agrega un nuevo usuario con privilegios de administrador completos a la base de datos Azure del servidor flexible Azure Database for PostgreSQL. Puede crear varios administradores de Microsoft Entra para cada servidor flexible de Azure Database for PostgreSQL.

¿Tiene algún problema? Póngase en contacto con nosotros.

Configuración de una regla de firewall para la instancia de Azure Database for PostgreSQL

Azure Database for PostgreSQL servidores flexibles son seguros de forma predeterminada. Tienen un firewall que bloquea todas las conexiones entrantes. Para usar la base de datos, agregue una regla de firewall que conceda acceso a la dirección IP local al servidor de bases de datos.

Como hemos configurado nuestra dirección IP local al principio de este artículo, puede abrir el firewall del servidor con el siguiente 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

Si se conecta al servidor flexible de Azure Database for PostgreSQL desde Subsistema de Windows para Linux (WSL) en un equipo con Windows, debe añadir el identificador de host de WSL al firewall.

Para obtener la dirección IP de la máquina host, ejecute el siguiente comando en WSL:

cat /etc/resolv.conf

Copie la dirección IP que sigue al término nameservery, a continuación, use el siguiente comando para establecer una variable de entorno para la dirección IP de WSL:

AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

A continuación, use el siguiente comando para abrir el firewall del servidor en la aplicación basada en 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

Configuración de una base de datos de Azure Database for PostgreSQL

Cree una base de datos mediante el comando siguiente:

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

Creación de un usuario que no es administrador de Azure Database for PostgreSQL y concesión de permiso

A continuación, cree un usuario que no sea administrador y concédale todos los permisos para la base de datos.

Nota:

Para obtener información más detallada sobre cómo administrar usuarios de Azure Database for PostgreSQL, consulte Administración de roles de Microsoft Entra en Azure Database for PostgreSQL.

Cree un script SQL denominado create_ad_user.sql para crear un usuario que no sea administrador. Agregue el siguiente contenido y guárdelo de forma local:

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

A continuación, use el siguiente comando para ejecutar el script SQL y crear el usuario que no sea administrador 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 el siguiente comando para quitar el archivo de script SQL temporal:

rm create_ad_user.sql

Creación de un nuevo proyecto de Java

Con su IDE favorito, cree un nuevo proyecto de Java mediante Java 8 o posterior. Agregue un archivo pom.xml en el directorio raíz con el siguiente contenido:

<?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 archivo es un archivo de Apache Maven que configura el proyecto para usar:

  • Java 8
  • Un reciente controlador de PostgreSQL para Java

Preparación de un archivo de configuración para conectarse a Azure Database for PostgreSQL

Cree un archivo src/main/resources/application.properties y agregue el siguiente contenido:

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

Nota:

La propiedad de configuración url incluye ?sslmode=require para asegurarse de que el controlador JDBC use TLS (Seguridad de la Capa de Transporte) al conectarse a la base de datos. El uso de TLS es obligatorio con Azure Database for PostgreSQL servidores flexibles y es una práctica de seguridad recomendada.

Creación de un archivo SQL para generar el esquema de la base de datos

Use un archivo src/main/resources/schema.sql para crear un esquema de base de datos. Cree ese archivo y agregue el siguiente contenido:

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

Programa la aplicación

En las secciones siguientes se explica cómo escribir el código Java que se conecta a la base de datos, define un modelo de datos y realiza operaciones CRUD básicas.

Conectarse a la base de datos

A continuación, agregue el código de Java que usa JDBC para almacenar y recuperar datos del servidor flexible Azure Database for PostgreSQL.

Cree un archivo src/main/java/DemoApplication.java y agregue el contenido siguiente:

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

¿Tiene algún problema? Póngase en contacto con nosotros.

Este código Java usa application.properties y los archivos schema.sql creados anteriormente para conectarse al servidor flexible de Azure Database for PostgreSQL y crear un esquema que almacene los datos.

En este archivo, los métodos para insertar, leer, actualizar y eliminar datos están comentados. El resto de este artículo le guía en la implementación de esos métodos, y puede descomentarlos uno tras otro.

Nota:

Las credenciales de la base de datos se almacenan en las propiedades user (usuario) y password (contraseña) del archivo application.properties. El código usa esas credenciales al ejecutar DriverManager.getConnection(properties.getProperty("url"), properties);, ya que el archivo de propiedades se pasa como argumento.

Ahora puede ejecutar esta clase principal con su herramienta favorita:

  • Con el IDE, puede hacer clic con el botón derecho en la clase DemoApplication y ejecutarla.
  • Con Maven, puede ejecutar la aplicación mediante la ejecución de: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".

La aplicación se conecta al servidor flexible Azure Database for PostgreSQL, crea un esquema de base de datos y, a continuación, cierra la conexión, como se ve en los registros de la consola:

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

Creación de una clase de dominio

Cree una nueva Todo clase Java junto a la DemoApplication clase y agregue el código siguiente:

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 clase es un modelo de dominio asignado a la todo tabla que creó al ejecutar el script de schema.sql .

Inserción de datos en Azure Database for PostgreSQL

En el archivo src/main/java/DemoApplication.java, después del método main, agregue el método siguiente para insertar los datos en la base de datos:

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

Ahora puede quitar la marca de comentario de las dos líneas siguientes en el método main:

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

Al ejecutar la clase principal, debe generar la siguiente salida:

[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

Leer datos de Azure Database for PostgreSQL

Para validar que el código funciona correctamente, lea los datos que insertó anteriormente.

En el archivo src/main/java/DemoApplication.java, después del método insertData, agregue el método siguiente para leer los datos de la base de datos:

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

Ahora puede quitar la marca de comentario de la línea siguiente en el método main:

todo = readData(connection);

Al ejecutar la clase principal, debe generar la siguiente salida:

[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

Actualizar datos en Azure Database for PostgreSQL

Para actualizar los datos, siga estos pasos.

En el archivo src/main/java/DemoApplication.java, después del método readData, agregue el método siguiente para actualizar los datos de la base de datos:

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

Ahora puede quitar la marca de comentario de las dos líneas siguientes en el método main:

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

Al ejecutar la clase principal, debe generar la siguiente salida:

[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 datos en Azure Database for PostgreSQL

Por último, elimine los datos que se insertaron anteriormente.

En el archivo src/main/java/DemoApplication.java, después del método updateData, agregue el método siguiente para eliminar los datos de la base de datos:

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

Ahora puede quitar la marca de comentario de la línea siguiente en el método main:

deleteData(todo, connection);

Al ejecutar la clase principal, debe generar la siguiente salida:

[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

Limpieza de recursos

Ha creado una aplicación de Java que usa JDBC para almacenar y recuperar datos de un servidor flexible Azure Database for PostgreSQL.

Para limpiar todos los recursos usados durante este inicio rápido, elimine el grupo de recursos mediante el siguiente comando:

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

Contenido relacionado

  • Last updated on