Implementación de una aplicación Java con Quarkus en un clúster de Azure Kubernetes Service
En este artículo se muestra cómo implementar rápidamente Red Hat Quarkus en Azure Kubernetes Service (AKS) con una sencilla aplicación CRUD. La aplicación es una "lista de tareas pendientes" con un front-end de JavaScript y un punto de conexión REST. Servidor flexible de Azure Database for PostgreSQL proporciona la capa de persistencia para la aplicación. En el artículo se muestra cómo probar la aplicación localmente e implementarla en AKS.
Prerrequisitos
- Si no tiene una suscripción a Azure, cree una cuenta gratuita de Azure antes de empezar.
- Prepara una máquina local con un sistema operativo similar a Unix instalado (por ejemplo, Ubuntu, macOS o Subsistema de Windows para Linux).
- Instala la versión 17 o una posterior de implementación de Java SE; por ejemplo, Compilación de Microsoft de OpenJDK.
- Instala Maven, versión 3.9.8 o posterior.
- Instale Docker para el sistema operativo.
- Instale jq.
- Instale cURL.
- Instala la CLI de Quarkus, versión 3.12.1 o posterior.
- CLI de Azure para entornos similares a Unix. En este artículo solo se requiere la variante bash de la CLI de Azure.
Un desarrollador debe instalar la CLI de Azure e iniciar sesión de forma interactiva con el comando az login para iniciar sesión en Azure antes de usar DefaultAzureCredential en el código. az login- Este artículo requiere al menos la versión 2.61.0 de la CLI de Azure.
Crear el proyecto de la aplicación
Use el siguiente comando para clonar el proyecto de Java de ejemplo para este artículo. El ejemplo se encuentra en GitHub.
git clone https://github.com/Azure-Samples/quarkus-azure
cd quarkus-azure
git checkout 2024-12-16
cd aks-quarkus
Si ve un mensaje acerca de estar en estado HEAD desasociado, este mensaje es seguro de omitir. Dado que este artículo no requiere ninguna confirmación, el estado HEAD desasociado es adecuado.
Prueba local de la aplicación Quarkus
Los pasos de esta sección muestran cómo ejecutar la aplicación localmente.
Quarkus admite el aprovisionamiento automático de servicios no configurados en modo de desarrollo y prueba. Quarkus hace referencia a esta funcionalidad como servicios de desarrollo. Supongamos que incluye una característica de Quarkus, como conectarse a un servicio de base de datos. Quiere probar la aplicación, pero aún no ha configurado completamente la conexión a una base de datos real. Quarkus inicia automáticamente una versión de código auxiliar contenedorizada del servicio pertinente a la que conecta la aplicación. Para obtener más información, consulte Información general de Dev Services en la documentación de Quarkus.
Asegúrese de que el entorno de contenedor está en ejecución y use el siguiente comando para activar el modo de desarrollo de Quarkus:
quarkus dev
En lugar de quarkus dev, puede lograr lo mismo con Maven mediante mvn quarkus:dev.
Es posible que se le pregunte si desea enviar telemetría de su uso del modo de desarrollo de Quarkus. Si es así, responda como quiera.
El modo de desarrollo de Quarkus habilita la recarga en vivo con la compilación en segundo plano. Si modifica algún aspecto del código fuente de la aplicación y actualiza el explorador, puede ver los cambios. Si hay algún problema con la compilación o la implementación, una página de error le informará. El modo de desarrollo de Quarkus escucha un depurador en el puerto 5005. Si desea esperar a que el depurador se adjunte antes de ejecutarse, pase -Dsuspend en la línea de comandos. Si no quiere el depurador en absoluto, puede usar -Ddebug=false.
La salida debería tener un aspecto similar al ejemplo siguiente:
__ ____ __ _____ ___ __ ____ ______
--/ __ \/ / / / _ | / _ \/ //_/ / / / __/
-/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
INFO [io.quarkus] (Quarkus Main Thread) quarkus-todo-demo-app-aks 1.0.0-SNAPSHOT on JVM (powered by Quarkus 3.2.0.Final) started in 3.377s. Listening on: http://localhost:8080
INFO [io.quarkus] (Quarkus Main Thread) Profile dev activated. Live Coding activated.
INFO [io.quarkus] (Quarkus Main Thread) Installed features: [agroal, cdi, hibernate-orm, hibernate-orm-panache, hibernate-validator, jdbc-postgresql, narayana-jta, resteasy-reactive, resteasy-reactive-jackson, smallrye-context-propagation, vertx]
--
Tests paused
Press [e] to edit command line args (currently ''), [r] to resume testing, [o] Toggle test output, [:] for the terminal, [h] for more options>
Presione w en el terminal donde se está ejecutando el modo de desarrollo de Quarkus. La tecla w abre el explorador web predeterminado para mostrar la aplicación Todo. También puede acceder a la GUI de la aplicación directamente en http://localhost:8080.
Intente seleccionar algunos elementos de tareas pendientes en la lista de tareas pendientes. La interfaz de usuario indica la selección con un estilo de texto tachado. También puede agregar un nuevo elemento de tareas pendientes a la lista de tareas pendientes si escribe Comprobar aplicaciones de tareas pendientes y presiona Entrar, como se muestra en el recorte de pantalla siguiente:
Acceda a la API de RESTful (/api) para obtener todos los elementos de tareas pendientes que se almacenan en la base de datos de PostgreSQL local:
curl --verbose http://localhost:8080/api | jq .
La salida debería tener un aspecto similar al ejemplo siguiente:
* Connected to localhost (127.0.0.1) port 8080 (#0)
> GET /api HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.88.1
> Accept: */*
>
< HTTP/1.1 200 OK
< content-length: 664
< Content-Type: application/json;charset=UTF-8
<
{ [664 bytes data]
100 664 100 664 0 0 13278 0 --:--:-- --:--:-- --:--:-- 15441
* Connection #0 to host localhost left intact
[
{
"id": 1,
"title": "Introduction to Quarkus Todo App",
"completed": false,
"order": 0,
"url": null
},
{
"id": 2,
"title": "Quarkus on Azure App Service",
"completed": false,
"order": 1,
"url": "https://learn.microsoft.com/en-us/azure/developer/java/eclipse-microprofile/deploy-microprofile-quarkus-java-app-with-maven-plugin"
},
{
"id": 3,
"title": "Quarkus on Azure Container Apps",
"completed": false,
"order": 2,
"url": "https://learn.microsoft.com/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
},
{
"id": 4,
"title": "Quarkus on Azure Functions",
"completed": false,
"order": 3,
"url": "https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-first-quarkus"
},
{
"id": 5,
"title": "Verify Todo apps",
"completed": false,
"order": 5,
"url": null
}
]
Presione q para salir del modo de desarrollo de Quarkus.
Creación de los recursos de Azure para ejecutar la aplicación Quarkus
Los pasos de esta sección muestran cómo crear los siguientes recursos de Azure para ejecutar la aplicación de ejemplo Quarkus:
- Servidor flexible de Azure Database for PostgreSQL
- Azure Container Registry
- Azure Kubernetes Service (AKS)
Nota:
En este artículo se deshabilita la autenticación de PostgreSQL para ilustrar los procedimientos recomendados de seguridad. Se usa Microsoft Entra ID para autenticar la conexión con el servidor. Si necesita habilitar la autenticación de PostgreSQL, vea Inicio rápido: Uso de Java y JDBC con Azure Database for PostgreSQL: servidor flexible y seleccione la pestaña Contraseña.
Algunos de estos recursos deben tener nombres únicos dentro del ámbito de la suscripción de Azure. Para garantizar esta unicidad, puede usar el patrón de iniciales, secuencia, fecha y sufijo. Para aplicar este patrón, asigne un nombre a los recursos enumerando las iniciales, algún número de secuencia, la fecha de hoy y algún tipo de sufijo específico del recurso, por ejemplo, rg para "grupo de recursos". Las siguientes variables de entorno utilizan este patrón. Reemplace los valores de marcador de posición UNIQUE_VALUE yLOCATION por valores propios y, después, ejecute los siguientes comandos en el terminal:
export UNIQUE_VALUE=<your unique value, such as ejb010717>
export RESOURCE_GROUP_NAME=${UNIQUE_VALUE}rg
export LOCATION=<your desired Azure region for deploying your resources - for example, northeurope>
export REGISTRY_NAME=${UNIQUE_VALUE}reg
export DB_SERVER_NAME=${UNIQUE_VALUE}db
export DB_NAME=demodb
export CLUSTER_NAME=${UNIQUE_VALUE}aks
export AKS_NS=${UNIQUE_VALUE}ns
Creación de servidor flexible de Azure Database for PostgreSQL
Servidor flexible de Azure Database for PostgreSQL es un servicio de base de datos totalmente administrado diseñado para proporcionar un control más granular y una mayor flexibilidad sobre las funciones de administración de bases de datos y las opciones de configuración. En esta sección se muestra cómo crear una instancia de servidor flexible de Azure Database for PostgreSQL mediante la CLI de Azure.
En primer lugar, crea un grupo de recursos que contenga el servidor de bases de datos y otros recursos mediante el siguiente comando:
az group create \
--name $RESOURCE_GROUP_NAME \
--location $LOCATION
A continuación, crea una instancia de servidor flexible de Azure Database for PostgreSQL mediante el comando siguiente:
az postgres flexible-server create \
--name $DB_SERVER_NAME \
--database-name $DB_NAME \
--resource-group $RESOURCE_GROUP_NAME \
--location $LOCATION \
--public-access 0.0.0.0 \
--sku-name Standard_B1ms \
--tier Burstable \
--active-directory-auth Enabled \
--yes
Se tarda unos minutos en crear el servidor, la base de datos, el usuario administrador y las reglas de firewall. Si el comando se ejecuta correctamente, la salida es similar al ejemplo siguiente:
{
"connectionString": "postgresql://REDACTED@ejb011212qdb.postgres.database.azure.com/demodb?sslmode=require",
"databaseName": "demodb",
"firewallName": "AllowAllAzureServicesAndResourcesWithinAzureIps_2024-12-12_14-30-22",
"host": "ejb011212qdb.postgres.database.azure.com",
"id": "/subscriptions/c7844e91-b11d-4a7f-ac6f-996308fbcdb9/resourceGroups/ejb011211sfi/providers/Microsoft.DBforPostgreSQL/flexibleServers/ejb011212qdb",
"location": "East US 2",
"password": "REDACTED",
"resourceGroup": "ejb011211sfi",
"skuname": "Standard_B1ms",
"username": "sorrycamel2",
"version": "16"
}
Prueba de la aplicación localmente con el servidor flexible de Azure Database for PostgreSQL
En la sección anterior, ha probado la aplicación Quarkus localmente en el modo de desarrollo con una base de datos PostgreSQL aprovisionada como un contenedor de Docker. Ahora probará la conexión a la instancia del servidor flexible de Azure Database for PostgreSQL localmente.
En primer lugar, agregue el usuario que ha iniciado sesión actual como administrador de Microsoft Entra a la instancia del servidor flexible de Azure Database for PostgreSQL mediante los siguientes comandos:
ENTRA_ADMIN_NAME=$(az account show --query user.name --output tsv)
az postgres flexible-server ad-admin create \
--resource-group $RESOURCE_GROUP_NAME \
--server-name $DB_SERVER_NAME \
--display-name $ENTRA_ADMIN_NAME \
--object-id $(az ad signed-in-user show --query id --output tsv)
La salida correcta es un objeto JSON que incluye la propiedad "type": "Microsoft.DBforPostgreSQL/flexibleServers/administrators".
A continuación, agregue la dirección IP local a las reglas de firewall de la instancia del servidor flexible de Azure Database for PostgreSQL mediante estos pasos:
Obtenga la dirección IP local del equipo donde se ejecuta la aplicación Quarkus localmente. Por ejemplo, visite https://whatismyipaddress.com para obtener la dirección IP pública v4.
Defina una variable de entorno con la dirección IP local que ha obtenido en el paso anterior.
export AZ_LOCAL_IP_ADDRESS=<your local IP address>Ejecute el comando siguiente para agregar la dirección IP local a las reglas de firewall de la instancia de servidor flexible de Azure Database for PostgreSQL:
az postgres flexible-server firewall-rule create \ --resource-group $RESOURCE_GROUP_NAME \ --name $DB_SERVER_NAME \ --rule-name $DB_SERVER_NAME-database-allow-local-ip \ --start-ip-address $AZ_LOCAL_IP_ADDRESS \ --end-ip-address $AZ_LOCAL_IP_ADDRESS
Después, establezca las siguientes variables de entorno en el terminal anterior. Estas variables de entorno se usan para conectarse a la instancia del servidor flexible de Azure Database for PostgreSQL desde la aplicación Quarkus que se ejecuta localmente:
export AZURE_POSTGRESQL_HOST=${DB_SERVER_NAME}.postgres.database.azure.com
export AZURE_POSTGRESQL_PORT=5432
export AZURE_POSTGRESQL_DATABASE=${DB_NAME}
export AZURE_POSTGRESQL_USERNAME=${ENTRA_ADMIN_NAME}
Nota:
Los valores de las variables de entorno AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASEy AZURE_POSTGRESQL_USERNAME son leídos por las propiedades de configuración de la base de datos definidas en el archivo src/main/resources/application.properties introducido en la sección anterior. Estos valores se insertan automáticamente en la aplicación en tiempo de ejecución mediante la extensión sin contraseña del conector de servicio al implementar la aplicación Quarkus en el clúster de AKS más adelante en este artículo.
Ahora, ejecute la aplicación Quarkus localmente para probar la conexión a la instancia del servidor flexible de Azure Database for PostgreSQL. Use el comando siguiente para iniciar la aplicación en modo de producción:
quarkus build
java -jar target/quarkus-app/quarkus-run.jar
Nota:
Si la aplicación no se inicia y se muestra un mensaje de error similar a ERROR [org.hib.eng.jdb.spi.SqlExceptionHelper] (JPA Startup Thread) Acquisition timeout while waiting for new connection, es muy probable que se deba a la configuración de red de la máquina local. Intente seleccionar Agregar dirección IP de cliente actual de nuevo desde Azure Portal. Para más información, vea la sección Creación de una regla de firewall después de crear un servidor en Creación y administración de reglas de firewall para servidor flexible de Azure Database for PostgreSQL mediante Azure Portal. Luego, vuelva a ejecutar la aplicación.
Abra un nuevo explorador web en http://localhost:8080 acceder a la aplicación Todo. Debería ver la aplicación Todo, con un aspecto similar a cuando la ha ejecutado localmente en modo de desarrollo.
Crear una instancia de Azure Container Registry
Dado que Quarkus es una tecnología nativa en la nube, tiene compatibilidad integrada para crear contenedores que se ejecutan en Kubernetes. Kubernetes depende completamente de tener un registro de contenedor desde el que encuentra las imágenes de contenedor que se van a ejecutar. AKS tiene compatibilidad integrada con Azure Container Registry.
Use el comando az acr create para crear la instancia del registro de contenedor. En el ejemplo siguiente se crea una instancia de registro de contenedor cuyo nombre es el valor de la variable de entorno ${REGISTRY_NAME}:
az acr create \
--resource-group $RESOURCE_GROUP_NAME \
--location ${LOCATION} \
--name $REGISTRY_NAME \
--sku Basic
Tras un breve período de tiempo, debería ver una salida JSON que contiene las siguientes líneas:
"provisioningState": "Succeeded",
"publicNetworkAccess": "Enabled",
"resourceGroup": "<YOUR_RESOURCE_GROUP>",
Obtenga el servidor de inicio de sesión de la instancia de registro de contenedor mediante el comando siguiente:
export LOGIN_SERVER=$(az acr show \
--name $REGISTRY_NAME \
--query 'loginServer' \
--output tsv)
echo $LOGIN_SERVER
Conexión de Docker a la instancia de registro de contenedor
Inicie sesión en la instancia de registro de contenedor. El inicio de sesión le permite insertar una imagen. Use el siguiente comando para iniciar sesión en el registro:
az acr login --name $REGISTRY_NAME
Si ha iniciado sesión correctamente en la instancia de registro de contenedor, debería ver Login Succeeded al final de la salida del comando.
Creación de un clúster de AKS
Use el comando az aks create para crear un clúster de AKS. En el ejemplo siguiente se crea un clúster denominado con el valor de la variable de entorno ${CLUSTER_NAME} con un nodo. El clúster está conectado a la instancia de registro de contenedor que ha creado en un paso anterior. El comando tarda varios minutos en completarse. El clúster se inicia con la identidad administrada habilitada. Este paso es necesario para la conexión de base de datos sin contraseña.
az aks create \
--resource-group $RESOURCE_GROUP_NAME \
--name $CLUSTER_NAME \
--attach-acr $REGISTRY_NAME \
--node-count 1 \
--generate-ssh-keys \
--enable-managed-identity
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster, incluida la siguiente salida:
"nodeResourceGroup": "MC_<your resource_group_name>_<your cluster name>_<your region>",
"privateFqdn": null,
"provisioningState": "Succeeded",
"resourceGroup": "<your resource group name>",
Conexión al clúster de AKS
Para administrar un clúster de Kubernetes, usará kubectl, el cliente de línea de comandos de Kubernetes. Para instalar kubectl localmente, use el comando az aks install-cli, como se muestra en el ejemplo siguiente:
az aks install-cli
Para más información sobre kubectl, consulte Herramienta de línea de comandos (kubectl) en la documentación de Kubernetes.
Para configurar kubectl para conectarse al clúster de Kubernetes, use el comando az aks get-credentials, como se muestra en el ejemplo siguiente. Con este comando se descargan las credenciales y se configura la CLI de Kubernetes para usarlas.
az aks get-credentials \
--resource-group $RESOURCE_GROUP_NAME \
--name $CLUSTER_NAME \
--overwrite-existing \
--admin
Si funciona correctamente, el resultado incluirá un texto similar al siguiente ejemplo:
Merged "ejb010718aks-admin" as current context in /Users/edburns/.kube/config
Es posible que le resulte útil establecer el alias k en kubectl. En ese caso, utilice el siguiente comando:
alias k=kubectl
Para comprobar la conexión al clúster, use el comando kubectl get para devolver una lista de los nodos del clúster, como se muestra en el ejemplo siguiente:
kubectl get nodes
La salida del ejemplo siguiente muestra el nodo único creado en los pasos anteriores. Asegúrese de que el estado del nodo es Listo:
NAME STATUS ROLES AGE VERSION
aks-nodepool1-xxxxxxxx-yyyyyyyyyy Ready agent 76s v1.28.9
Creación de un nuevo espacio de nombres en AKS
Use el siguiente comando para crear un nuevo espacio de nombres en el servicio Kubernetes para la aplicación Quarkus:
kubectl create namespace ${AKS_NS}
La salida debería tener un aspecto similar al ejemplo siguiente:
namespace/<your namespace> created
Creación de una conexión de servicio en AKS con Service Connector
En esta sección, creará una conexión de servicio entre el clúster de AKS y el servidor flexible de Azure Database for PostgreSQL mediante Id. de carga de trabajo de Microsoft Entra con Service Connector. Esta conexión permite que el clúster de AKS acceda al servidor flexible de Azure Database for PostgreSQL sin usar la autenticación de SQL.
Ejecute los comandos siguientes para crear una conexión entre el clúster de AKS y la base de datos PostgreSQL mediante Id. de carga de trabajo de Microsoft Entra con Service Connector:
# Register the Service Connector and Kubernetes Configuration resource providers
az provider register --namespace Microsoft.ServiceLinker --wait
az provider register --namespace Microsoft.KubernetesConfiguration --wait
# Install the Service Connector passwordless extension
az extension add --name serviceconnector-passwordless --upgrade --allow-preview true
# Retrieve the AKS cluster and Azure SQL Server resource IDs
export AKS_CLUSTER_RESOURCE_ID=$(az aks show \
--resource-group $RESOURCE_GROUP_NAME \
--name $CLUSTER_NAME \
--query id \
--output tsv)
export AZURE_POSTGRESQL_RESOURCE_ID=$(az postgres flexible-server show \
--resource-group $RESOURCE_GROUP_NAME \
--name $DB_SERVER_NAME \
--query id \
--output tsv)
# Create a user-assigned managed identity used for workload identity
export USER_ASSIGNED_IDENTITY_NAME=workload-identity-uami
az identity create \
--resource-group ${RESOURCE_GROUP_NAME} \
--name ${USER_ASSIGNED_IDENTITY_NAME}
# Retrieve the user-assigned managed identity resource ID
export UAMI_RESOURCE_ID=$(az identity show \
--resource-group ${RESOURCE_GROUP_NAME} \
--name ${USER_ASSIGNED_IDENTITY_NAME} \
--query id \
--output tsv)
# Create a service connection between your AKS cluster and your PostgreSQL database using Microsoft Entra Workload ID
az aks connection create postgres-flexible \
--connection akspostgresconn \
--kube-namespace $AKS_NS \
--source-id $AKS_CLUSTER_RESOURCE_ID \
--target-id $AZURE_POSTGRESQL_RESOURCE_ID/databases/$DB_NAME \
--workload-identity $UAMI_RESOURCE_ID
La presencia del siguiente código JSON en la salida del comando final en los pasos anteriores indica una instalación correcta del conector de servicio:
"name": "akspostgresconn",
"provisioningState": "Succeeded",
Nota:
Se recomienda usar Id. de carga de trabajo de Microsoft Entra para el acceso seguro al servidor flexible de Azure Database for PostgreSQL sin usar la autenticación mediante nombre de usuario y contraseña. Si necesita usar la autenticación mediante nombre de usuario y contraseña, omita los pasos anteriores de esta sección y use el nombre de usuario y la contraseña para conectarse a la base de datos.
Obtención de la cuenta de servicio y el secreto creado por el conector de servicio
Para autenticarse en el servidor flexible de Azure Database for PostgreSQL, debe obtener la cuenta de servicio y el secreto de Kubernetes creados por Service Connector. Siga las instrucciones de la sección Actualización del contenedor de Tutorial: Conexión de una aplicación de AKS a Azure SQL Database. Elija la opción Crear directamente una implementación mediante el fragmento de código de ejemplo de YAML proporcionado y siga este paso:
En las secciones resaltadas del ejemplo de código YAML de implementación de Kubernetes, copie los valores
serviceAccountNameysecretRef.name, representados como<service-account-name>y<secret-name>en el ejemplo siguiente:serviceAccountName: <service-account-name> containers: - name: raw-linux envFrom: - secretRef: name: <secret-name>Estos valores se usan en la sección siguiente para implementar la aplicación Quarkus en el clúster de AKS.
Personalización de la configuración nativa de la nube
Como tecnología nativa en la nube, Quarkus ofrece la capacidad de configurar automáticamente recursos para Kubernetes estándar, Red Hat OpenShift y Knative. Para más información, vea la Guía de Kubernetes de Quarkus, Guía de OpenShift de Quarkus y Guía de Quarkus Knative. Los desarrolladores pueden implementar la aplicación en un clúster de Kubernetes de destino aplicando los manifiestos generados.
Para generar los recursos de Kubernetes adecuados, use el siguiente comando para agregar las extensiones quarkus-kubernetes y container-image-jib en el terminal local:
quarkus ext add kubernetes container-image-jib
Quarkus modifica el POM para asegurarse de que estas extensiones se enumeran como <dependencies>. Si se le pide que instale algo llamado JBang, responda sí y permita que se instale.
La salida debería tener un aspecto similar al ejemplo siguiente:
[SUCCESS] ✅ Extension io.quarkus:quarkus-kubernetes has been installed
[SUCCESS] ✅ Extension io.quarkus:quarkus-container-image-jib has been installed
Para comprobar que se agregan las extensiones, puede ejecutar git diff y examinar la salida.
Como tecnología nativa en la nube, Quarkus admite la noción de perfiles de configuración. Quarkus tiene los tres perfiles integrados siguientes:
dev- Activado cuando está en modo de desarrollotest- Activado al ejecutar pruebasprod- El perfil predeterminado cuando no se ejecuta en modo de desarrollo o prueba
Quarkus admite cualquier número de perfiles con nombre, según sea necesario.
En los pasos restantes de esta sección se le muestra cómo personalizar los valores del archivo src/main/resources/application.properties.
El prefijo prod. indica que estas propiedades están activas al ejecutarse en el perfil prod. Para obtener más información sobre los perfiles de configuración, consulte la documentación de Quarkus.
Configuración de la base de datos
Examine las siguientes variables de configuración de base de datos. Las propiedades relacionadas con la conexión de base de datos %prod.quarkus.datasource.jdbc.url y %prod.quarkus.datasource.username leen valores de las variables de entorno AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASE y AZURE_POSTGRESQL_USERNAME respectivamente. Estas variables de entorno se asignan a valores secretos que almacenan la información de conexión de la base de datos. Por motivos de seguridad, se generan automáticamente mediante la extensión sin contraseña Service Connector, como se muestra en otra parte de este artículo.
# Database configurations
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://${AZURE_POSTGRESQL_HOST}:${AZURE_POSTGRESQL_PORT}/${AZURE_POSTGRESQL_DATABASE}?\
authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin\
&sslmode=require
%prod.quarkus.datasource.username=${AZURE_POSTGRESQL_USERNAME}
%prod.quarkus.datasource.jdbc.acquisition-timeout=10
%prod.quarkus.hibernate-orm.database.generation=drop-and-create
%prod.quarkus.hibernate-orm.sql-load-script=import.sql
Configuración de Kubernetes
Examine las siguientes variables de configuración de Kubernetes. service-type se establece en load-balancer para acceder a la aplicación externamente. Reemplace los valores de <service-account-name> y <secret-name> por los de los valores reales que ha copiado en la sección anterior.
# Kubernetes configurations
%prod.quarkus.kubernetes.deployment-target=kubernetes
%prod.quarkus.kubernetes.service-type=load-balancer
%prod.quarkus.kubernetes.labels."azure.workload.identity/use"=true
%prod.quarkus.kubernetes.service-account=<service-account-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_CLIENT_ID.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_CLIENT_ID.with-key=AZURE_POSTGRESQL_CLIENTID
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_HOST.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_HOST.with-key=AZURE_POSTGRESQL_HOST
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_PORT.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_PORT.with-key=AZURE_POSTGRESQL_PORT
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_DATABASE.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_DATABASE.with-key=AZURE_POSTGRESQL_DATABASE
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_USERNAME.from-secret=<secret-name>
%prod.quarkus.kubernetes.env.mapping.AZURE_POSTGRESQL_USERNAME.with-key=AZURE_POSTGRESQL_USERNAME
Las demás configuraciones de Kubernetes especifican la asignación de los valores secretos a las variables de entorno de la aplicación Quarkus. El secreto de <secret-name> contiene la información de conexión de la base de datos. Las claves AZURE_POSTGRESQL_CLIENTID, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASE y AZURE_POSTGRESQL_USERNAME del secreto se asignan a las variables de entorno AZURE_CLIENT_ID, AZURE_POSTGRESQL_HOST, AZURE_POSTGRESQL_PORT, AZURE_POSTGRESQL_DATABASE y AZURE_POSTGRESQL_USERNAME respectivamente.
Para examinar los secretos directamente con kubectl, use comandos similares a los del ejemplo siguiente:
kubectl -n ${AKS_NS} get secret <secret-name> -o jsonpath="{.data.AZURE_POSTGRESQL_USERNAME}" | base64 --decode
Configuración de la imagen de contenedor
Como tecnología nativa en la nube, Quarkus admite la generación de imágenes de contenedor OCI compatibles con Docker. Reemplace el valor de <LOGIN_SERVER_VALUE> por el valor real de la variable de entorno ${LOGIN_SERVER}.
# Container Image Build
%prod.quarkus.container-image.build=true
%prod.quarkus.container-image.image=<LOGIN_SERVER_VALUE>/todo-quarkus-aks:1.0
Como comprobación final, cuando complete todas las sustituciones necesarias en application.properties, no debe haber repeticiones del carácter <. Si las hay, compruebe que ha completado todas las sustituciones necesarias.
Compilación de la imagen de contenedor e inserción en el registro de contenedor
Ahora, use el siguiente comando para compilar la propia aplicación. Este comando usa las extensiones Kubernetes y Jib para compilar la imagen de contenedor.
quarkus build --no-tests
La salida debe terminar con BUILD SUCCESS. Los archivos de manifiesto de Kubernetes se generan en target/kubernetes, como se muestra en el ejemplo siguiente:
tree target/kubernetes
target/kubernetes
├── kubernetes.json
└── kubernetes.yml
0 directories, 2 files
También puede comprobar si se genera la imagen de contenedor mediante la línea de comandos (CLI) docker. El resultado es similar al ejemplo siguiente:
docker images | grep todo-quarkus-aks
<LOGIN_SERVER_VALUE>/todo-quarkus-aks 1.0 b13c389896b7 18 minutes ago 422MB
Inserte las imágenes de contenedor en el registro de contenedor mediante el siguiente comando:
export TODO_QUARKUS_TAG=$(docker images | grep todo-quarkus-aks | head -n1 | cut -d " " -f1)
echo ${TODO_QUARKUS_TAG}
docker push ${TODO_QUARKUS_TAG}:1.0
La salida debería tener un aspecto similar al ejemplo siguiente:
The push refers to repository [<LOGIN_SERVER_VALUE>/todo-quarkus-aks]
dfd615499b3a: Pushed
56f5cf1aa271: Pushed
4218d39b228e: Pushed
b0538737ed64: Pushed
d13845d85ee5: Pushed
60609ec85f86: Pushed
1.0: digest: sha256:0ffd70d6d5bb3a4621c030df0d22cf1aa13990ca1880664d08967bd5bab1f2b6 size: 1995
Ahora que ha insertado la aplicación en el registro de contenedor, puede indicar a AKS que la ejecute.
Implementación de la aplicación Quarkus en AKS
En los pasos de esta sección se muestra cómo ejecutar la aplicación de ejemplo Quarkus en los recursos de Azure que ha creado.
Uso de kubectl para implementar la aplicación Quarkus en AKS
Implemente los recursos de Kubernetes mediante kubectl en la línea de comandos, como se muestra en el ejemplo siguiente:
kubectl apply -f target/kubernetes/kubernetes.yml -n ${AKS_NS}
La salida debería tener un aspecto similar al ejemplo siguiente:
service/quarkus-todo-demo-app-aks created
deployment.apps/quarkus-todo-demo-app-aks created
Compruebe que la aplicación se está ejecutando con el siguiente comando:
kubectl -n $AKS_NS get pods
Si el valor del campo STATUS muestra algo distinto de Running, solucione y resuelva el problema antes de continuar. Es posible que sea útil examinar los registros de pod mediante el siguiente comando:
kubectl -n $AKS_NS logs $(kubectl -n $AKS_NS get pods | grep quarkus-todo-demo-app-aks | cut -d " " -f1)
Obtenga EXTERNAL-IP para acceder a la aplicación Tareas pendientes mediante el siguiente comando:
kubectl get svc -n ${AKS_NS}
La salida debería tener un aspecto similar al ejemplo siguiente:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
quarkus-todo-demo-app-aks LoadBalancer 10.0.236.101 20.12.126.200 80:30963/TCP 37s
Puede usar el siguiente comando para guardar el valor de EXTERNAL-IP en una variable de entorno como una dirección URL completa:
export QUARKUS_URL=http://$(kubectl get svc -n ${AKS_NS} | grep quarkus-todo-demo-app-aks | cut -d " " -f10)
echo $QUARKUS_URL
Abra un nuevo explorador web en el valor de ${QUARKUS_URL}. A continuación, agregue un nuevo elemento de tareas pendientes con el texto Deployed the Todo app to AKS. Además, seleccione el elemento Introduction to Quarkus Todo App como completado.
Acceda a la API de RESTful (/api) para obtener todos los elementos de tareas pendientes almacenados en la base de datos de Azure PostgreSQL, como se muestra en el ejemplo siguiente:
curl --verbose ${QUARKUS_URL}/api | jq .
La salida debería tener un aspecto similar al ejemplo siguiente:
* Connected to 20.237.68.225 (20.237.68.225) port 80 (#0)
> GET /api HTTP/1.1
> Host: 20.237.68.225
> User-Agent: curl/7.88.1
> Accept: */*
>
< HTTP/1.1 200 OK
< content-length: 828
< Content-Type: application/json;charset=UTF-8
<
[
{
"id": 2,
"title": "Quarkus on Azure App Service",
"completed": false,
"order": 1,
"url": "https://learn.microsoft.com/en-us/azure/developer/java/eclipse-microprofile/deploy-microprofile-quarkus-java-app-with-maven-plugin"
},
{
"id": 3,
"title": "Quarkus on Azure Container Apps",
"completed": false,
"order": 2,
"url": "https://learn.microsoft.com/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
},
{
"id": 4,
"title": "Quarkus on Azure Functions",
"completed": false,
"order": 3,
"url": "https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-first-quarkus"
},
{
"id": 5,
"title": "Deployed the Todo app to AKS",
"completed": false,
"order": 5,
"url": null
},
{
"id": 1,
"title": "Introduction to Quarkus Todo App",
"completed": true,
"order": 0,
"url": null
}
]
Comprobación de que la base de datos está actualizada
Ejecute el siguiente comando para comprobar que la base de datos ya se ha actualizado correctamente:
ACCESS_TOKEN=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken)
az postgres flexible-server execute \
--admin-user $ENTRA_ADMIN_NAME \
--admin-password $ACCESS_TOKEN \
--name $DB_SERVER_NAME \
--database-name $DB_NAME \
--querytext "select * from todo;"
Si se le pide que instale una extensión, responda Y.
La salida debe ser similar a la del ejemplo siguiente y debe incluir los mismos elementos en la GUI de la aplicación de tareas pendientes y de la salida del comando curl anterior:
Successfully connected to <DB_SERVER_NAME>.
Ran Database Query: 'select * from todo;'
Retrieving first 30 rows of query output, if applicable.
Closed the connection to <DB_SERVER_NAME>
[
{
"completed": false,
"id": 2,
"ordering": 1,
"title": "Quarkus on Azure App Service",
"url": "https://learn.microsoft.com/en-us/azure/developer/java/eclipse-microprofile/deploy-microprofile-quarkus-java-app-with-maven-plugin"
},
{
"completed": false,
"id": 3,
"ordering": 2,
"title": "Quarkus on Azure Container Apps",
"url": "https://learn.microsoft.com/en-us/training/modules/deploy-java-quarkus-azure-container-app-postgres/"
},
{
"completed": false,
"id": 4,
"ordering": 3,
"title": "Quarkus on Azure Functions",
"url": "https://learn.microsoft.com/en-us/azure/azure-functions/functions-create-first-quarkus"
},
{
"completed": false,
"id": 5,
"ordering": 5,
"title": "Deployed the Todo app to AKS",
"url": null
},
{
"completed": true,
"id": 1,
"ordering": 0,
"title": "Introduction to Quarkus Todo App",
"url": null
}
]
Cuando haya terminado, elimine la regla de firewall que permite que la dirección IP local acceda a la instancia de servidor flexible de Azure Database for PostgreSQL mediante el comando siguiente:
az postgres flexible-server firewall-rule delete \
--resource-group $RESOURCE_GROUP_NAME \
--name $DB_SERVER_NAME \
--rule-name $DB_SERVER_NAME-database-allow-local-ip \
--yes
Limpieza de recursos
Para evitar los cargos de Azure, se recomienda limpiar los recursos que no sean necesarios. Cuando el clúster ya no se necesite, puede usar el comando az group delete para quitar el grupo de recursos, el servicio de contenedor, el registro de contenedor y todos los recursos relacionados.
git reset --hard
docker rmi ${TODO_QUARKUS_TAG}:1.0
docker rmi postgres
az identity delete --ids ${UAMI_RESOURCE_ID}
az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait
Es posible que también quiera usar docker rmi para eliminar las imágenes de contenedor postgres y testcontainers generadas por el modo de desarrollo de Quarkus.
Pasos siguientes
Azure Kubernetes Service