Implantar um aplicativo Java com o Quarkus em um cluster do Serviço Kubernetes do Azure
Este artigo mostra como implantar rapidamente o Red Hat Quarkus no Serviço Kubernetes do Azure (AKS) com um aplicativo CRUD simples. O aplicativo é uma "lista de tarefas" com um front-end JavaScript e um ponto de extremidade REST. O Banco de Dados do Azure para PostgreSQL fornece a camada de persistência para o aplicativo. O artigo mostra como testar seu aplicativo localmente e implantá-lo no AKS.
Pré-requisitos
- Se não tiver uma subscrição do Azure, crie uma conta gratuita do Azure antes de começar.
- O Azure Cloud Shell tem todos esses pré-requisitos pré-instalados. Para saber mais, consulte Guia de início rápido para o Azure Cloud Shell.
- Se você estiver executando os comandos neste guia localmente (em vez de usar o Azure Cloud Shell), conclua as seguintes etapas:
- Prepare uma máquina local com o sistema operacional Unix-like instalado (por exemplo, Ubuntu, macOS ou Windows Subsystem for Linux).
- Instale uma implementação Java SE (por exemplo, compilação Microsoft do OpenJDK).
- Instale o Maven 3.5.0 ou superior.
- Instale o Docker ou o Podman para o seu sistema operacional.
- Instale o jq.
- Instale o cURL.
- Instale a CLI do Quarkus.
- CLI do Azure para ambientes Unix-like. Este artigo requer apenas a variante Bash da CLI do Azure.
Um desenvolvedor deve instalar a CLI do Azure e entrar interativamente com o comando az login para fazer logon no Azure antes de usar o código DefaultAzureCredential. az login- Este artigo requer pelo menos a versão 2.31.0 da CLI do Azure. Se estiver usando o Azure Cloud Shell, a versão mais recente já está instalada.
Criar o projeto de aplicativo
Use o comando a seguir para clonar o projeto Java de exemplo para este artigo. O exemplo está no GitHub.
git clone https://github.com/Azure-Samples/quarkus-azure
cd quarkus-azure
git checkout 2023-07-17
cd aks-quarkus
Se você vir uma mensagem sobre estar no estado HEAD desanexado, essa mensagem é segura para ignorar. Como este artigo não requer nenhuma confirmação, o estado HEAD destacado é apropriado.
Teste seu aplicativo Quarkus localmente
As etapas nesta seção mostram como executar o aplicativo localmente.
O Quarkus suporta o provisionamento automático de serviços não configurados no modo de desenvolvimento e teste. O Quarkus refere-se a esse recurso como serviços de desenvolvimento. Digamos que você inclua um recurso do Quarkus, como conectar-se a um serviço de banco de dados. Você deseja testar o aplicativo, mas ainda não configurou totalmente a conexão com um banco de dados real. O Quarkus inicia automaticamente uma versão de stub do serviço relevante e conecta seu aplicativo a ele. Para obter mais informações, consulte Visão geral dos serviços de desenvolvimento na documentação do Quarkus.
Verifique se seu ambiente de contêiner, Docker ou Podman, está em execução e use o seguinte comando para entrar no modo de desenvolvimento do Quarkus:
quarkus dev
Em vez de quarkus dev, você pode realizar a mesma coisa com o Maven usando mvn quarkus:dev.
Você pode ser perguntado se deseja enviar telemetria do seu uso do modo de desenvolvimento do Quarkus. Se sim, responda como quiser.
O modo de desenvolvimento do Quarkus permite a recarga ao vivo com compilação em segundo plano. Se você modificar qualquer aspeto do código-fonte do aplicativo e atualizar o navegador, poderá ver as alterações. Se houver algum problema com a compilação ou implantação, uma página de erro informará você. O modo de desenvolvimento do Quarkus escuta um depurador na porta 5005. Se você quiser esperar que o depurador anexe antes de executar, passe -Dsuspend a linha de comando. Se você não quiser o depurador, você pode usar -Ddebug=falseo .
A saída deve ser semelhante ao exemplo a seguir:
__ ____ __ _____ ___ __ ____ ______
--/ __ \/ / / / _ | / _ \/ //_/ / / / __/
-/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
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>
Pressione w no terminal onde o modo de desenvolvimento do Quarkus está sendo executado. A tecla w abre o navegador da Web padrão para mostrar o Todo aplicativo. Você também pode acessar a GUI do aplicativo diretamente http://localhost:8080 .
Tente selecionar alguns itens de todo na lista de tarefas. A interface do usuário indica a seleção com um estilo de texto tachado. Você também pode adicionar um novo item todo à lista todo digitando Verify Todo apps e pressionando ENTER, conforme mostrado na captura de tela a seguir:
Acesse a API RESTful (/api) para obter todos os itens que são armazenados no banco de dados PostgreSQL local:
curl --verbose http://localhost:8080/api | jq .
A saída deve ser semelhante ao exemplo a seguir:
* 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
}
]
Pressione q para sair do modo de desenvolvimento do Quarkus.
Criar os recursos do Azure para executar o aplicativo Quarkus
As etapas nesta seção mostram como criar os seguintes recursos do Azure para executar o aplicativo de exemplo Quarkus:
- Base de Dados do Azure para PostgreSQL
- Azure Container Registry (ACR)
- Azure Kubernetes Service (AKS)
Alguns desses recursos devem ter nomes exclusivos dentro do escopo da assinatura do Azure. Para garantir essa exclusividade, você pode usar as iniciais, sequência, data, padrão de sufixo. Para aplicar esse padrão, nomeie seus recursos listando suas iniciais, algum número de sequência, a data de hoje e algum tipo de sufixo específico de recurso - por exemplo, rg para "grupo de recursos". Use os seguintes comandos para definir algumas variáveis de ambiente a serem usadas posteriormente:
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, eastus>
export REGISTRY_NAME=${UNIQUE_VALUE}reg
export DB_SERVER_NAME=${UNIQUE_VALUE}db
export CLUSTER_NAME=${UNIQUE_VALUE}aks
export AKS_NS=${UNIQUE_VALUE}ns
Criar uma Base de Dados do Azure para o PostgreSQL
O Banco de Dados do Azure para PostgreSQL é um serviço gerenciado para executar, gerenciar e dimensionar bancos de dados PostgreSQL altamente disponíveis na nuvem do Azure. Esta seção direciona você para um início rápido separado que mostra como criar um único Banco de Dados do Azure para o servidor PostgreSQL e conectar-se a ele. No entanto, ao seguir as etapas no início rápido, você precisa usar as configurações na tabela a seguir para personalizar a implantação do banco de dados para o aplicativo Quarkus de exemplo. Substitua as variáveis de ambiente por seus valores reais ao preencher os campos no portal do Azure.
| Definição | valor | Description |
|---|---|---|
| Grupo de recursos | ${RESOURCE_GROUP_NAME} |
Selecione Criar novo. A implantação cria esse novo grupo de recursos. |
| Nome do servidor | ${DB_SERVER_NAME} |
Esse valor faz parte do nome do host para o servidor de banco de dados. |
| Localização | ${LOCATION} |
Selecione um local na lista suspensa. Tome nota da localização. Você deve usar esse mesmo local para outros recursos do Azure criados. |
| Nome de utilizador de administrador | Quarkus | O código de exemplo assume esse valor. |
| Palavra-passe | Segredo123456 | O código de exemplo assume esse valor. |
Com essas substituições de valor em mente, siga as etapas em Guia de início rápido: criar um banco de dados do Azure para o servidor PostgreSQL usando o portal do Azure até a seção "Configurar uma regra de firewall". Em seguida, na seção "Configurar uma regra de firewall", selecione Sim para Permitir acesso aos serviços do Azure e selecione Salvar. Se você negligenciar isso, seu aplicativo Quarkus não poderá acessar o banco de dados e simplesmente não será iniciado.
Depois de concluir as etapas no início rápido através da seção "Configurar uma regra de firewall", incluindo a etapa para permitir o acesso aos serviços do Azure, volte a este artigo.
Criar um banco de dados Todo no PostgreSQL
O servidor PostgreSQL que você criou anteriormente está vazio. Ele não tem nenhum banco de dados que você possa usar com o aplicativo Quarkus. Crie um novo banco de dados chamado todo usando o seguinte comando:
az postgres db create \
--resource-group ${RESOURCE_GROUP_NAME} \
--name todo \
--server-name ${DB_SERVER_NAME}
Você deve usar todo como o nome do banco de dados porque o código de exemplo pressupõe esse nome do banco de dados.
Se o comando for bem-sucedido, a saída será semelhante ao exemplo a seguir:
{
"charset": "UTF8",
"collation": "English_United States.1252",
"id": "/subscriptions/REDACTED/resourceGroups/ejb010718rg/providers/Microsoft.DBforPostgreSQL/servers/ejb010718db/databases/todo",
"name": "todo",
"resourceGroup": "ejb010718rg",
"type": "Microsoft.DBforPostgreSQL/servers/databases"
}
Criar uma instância do Registro de Contêiner do Microsoft Azure
Como o Quarkus é uma tecnologia nativa da nuvem, ele tem suporte interno para a criação de contêineres que são executados no Kubernetes. O Kubernetes depende inteiramente de ter um registro de contêiner a partir do qual ele encontra as imagens de contêiner a serem executadas. O AKS tem suporte interno para o Azure Container Registry (ACR).
Use o comando az acr create para criar a instância do ACR. O exemplo a seguir cria uma instância ACR nomeada com o valor da variável ${REGISTRY_NAME}de ambiente:
az acr create \
--resource-group $RESOURCE_GROUP_NAME \
--location ${LOCATION} \
--name $REGISTRY_NAME \
--sku Basic \
--admin-enabled
Após um curto período de tempo, você verá a saída JSON que contém as seguintes linhas:
"provisioningState": "Succeeded",
"publicNetworkAccess": "Enabled",
"resourceGroup": "<YOUR_RESOURCE_GROUP>",
Conecte o docker à instância do ACR
Entre na instância ACR. Iniciar sessão permite-lhe enviar uma imagem por push. Use os seguintes comandos para verificar a conexão:
export LOGIN_SERVER=$(az acr show \
--name $REGISTRY_NAME \
--query 'loginServer' \
--output tsv)
echo $LOGIN_SERVER
export USER_NAME=$(az acr credential show \
--name $REGISTRY_NAME \
--query 'username' \
--output tsv)
echo $USER_NAME
export PASSWORD=$(az acr credential show \
--name $REGISTRY_NAME \
--query 'passwords[0].value' \
--output tsv)
echo $PASSWORD
docker login $LOGIN_SERVER -u $USER_NAME -p $PASSWORD
Se você estiver usando o Podman em vez do Docker, faça as alterações necessárias no comando.
Se você entrou na instância ACR com êxito, deverá ver Login Succeeded no final da saída do comando.
Criar um cluster do AKS
Utilize o comando az aks create para criar um cluster AKS. O exemplo a seguir cria um cluster nomeado com o valor da variável ${CLUSTER_NAME} de ambiente com um nó. O cluster está conectado à instância ACR criada em uma etapa anterior. Este comando leva vários minutos para ser concluído.
az aks create \
--resource-group $RESOURCE_GROUP_NAME \
--location ${LOCATION} \
--name $CLUSTER_NAME \
--attach-acr $REGISTRY_NAME \
--node-count 1 \
--generate-ssh-keys \
--enable-managed-identity
Após alguns minutos, o comando conclui e retorna informações formatadas em JSON sobre o cluster, incluindo a seguinte saída:
"nodeResourceGroup": "MC_<your resource_group_name>_<your cluster name>_<your region>",
"privateFqdn": null,
"provisioningState": "Succeeded",
"resourceGroup": "<your resource group name>",
Conectar-se ao cluster AKS
Para gerenciar um cluster Kubernetes, use kubectl, o cliente de linha de comando Kubernetes. Se você usa o Azure Cloud Shell, kubectl já está instalado. Para instalar kubectl localmente, use o comando az aks install-cli , conforme mostrado no exemplo a seguir:
az aks install-cli
Para obter mais informações sobre kubectlo , consulte Ferramenta de linha de comando (kubectl) na documentação do Kubernetes.
Para configurar kubectl para se conectar ao cluster do Kubernetes, use o comando az aks get-credentials , conforme mostrado no exemplo a seguir. Este comando baixa credenciais e configura a CLI do Kubernetes para usá-las.
az aks get-credentials \
--resource-group $RESOURCE_GROUP_NAME \
--name $CLUSTER_NAME \
--overwrite-existing \
--admin
A saída bem-sucedida inclui texto semelhante ao exemplo a seguir:
Merged "ejb010718aks-admin" as current context in /Users/edburns/.kube/config
Você pode achar útil o alias k para kubectl. Em caso afirmativo, use o seguinte comando:
alias k=kubectl
Para verificar a conexão com o cluster, use o kubectl get comando para retornar uma lista dos nós do cluster, conforme mostrado no exemplo a seguir:
kubectl get nodes
A saída de exemplo seguinte mostra o nó único criado nos passos anteriores. Verifique se o status do nó está Pronto:
NAME STATUS ROLES AGE VERSION
aks-nodepool1-xxxxxxxx-yyyyyyyyyy Ready agent 76s v1.23.8
Criar um novo namespace no AKS
Use o seguinte comando para criar um novo namespace em seu serviço Kubernetes para seu aplicativo Quarkus:
kubectl create namespace ${AKS_NS}
A saída deve ser semelhante ao exemplo a seguir:
namespace/<your namespace> created
Personalizar a configuração nativa da nuvem
Como uma tecnologia nativa da nuvem, o Quarkus oferece a capacidade de configurar automaticamente recursos para Kubernetes padrão, Red Hat OpenShift e Knative. Para obter mais informações, consulte o guia do Quarkus Kubernetes, o guia do Quarkus OpenShift e o guia do Quarkus Kunative. Os desenvolvedores podem implantar o aplicativo em um cluster Kubernetes de destino aplicando os manifestos gerados.
Para gerar os recursos Kubernetes apropriados, use o seguinte comando para adicionar as quarkus-kubernetes extensões e container-image-jib em seu terminal local:
quarkus ext add kubernetes container-image-jib
O Quarkus modifica o POM para garantir que essas extensões sejam listadas como <dependencies>. Se lhe for pedido para instalar algo chamado JBang, responda sim e permita que seja instalado.
A saída deve ser semelhante ao exemplo a seguir:
[SUCCESS] ✅ Extension io.quarkus:quarkus-kubernetes has been installed
[SUCCESS] ✅ Extension io.quarkus:quarkus-container-image-jib has been installed
Para verificar se as extensões foram adicionadas, você pode executar git diff e examinar a saída.
Como uma tecnologia nativa da nuvem, o Quarkus suporta a noção de perfis de configuração. O Quarkus tem os seguintes três perfis integrados:
dev- Ativado quando em modo de desenvolvimentotest- Ativado durante a execução de testesprod- O perfil padrão quando não está em execução no modo de desenvolvimento ou teste
O Quarkus suporta qualquer número de perfis nomeados, conforme necessário.
As etapas restantes nesta seção direcionam você para descomentar e personalizar valores no arquivo src/main/resources/application.properties . Certifique-se de que todas as linhas que começam com # %prod. não são comentadas, removendo a entrelinha #.
O prod. prefixo indica que essas propriedades estão ativas quando executadas prod no perfil. Para obter mais informações sobre perfis de configuração, consulte a documentação do Quarkus.
Configuração da base de dados
Adicione as seguintes variáveis de configuração do banco de dados. Substitua os valores de <DB_SERVER_NAME_VALUE> pelos valores reais da ${DB_SERVER_NAME} variável de ambiente.
# Database configurations
%prod.quarkus.datasource.db-kind=postgresql
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://<DB_SERVER_NAME_VALUE>.postgres.database.azure.com:5432/todo
%prod.quarkus.datasource.jdbc.driver=org.postgresql.Driver
%prod.quarkus.datasource.username=quarkus@<DB_SERVER_NAME_VALUE>
%prod.quarkus.datasource.password=Secret123456
%prod.quarkus.hibernate-orm.database.generation=drop-and-create
Configuração do Kubernetes
Adicione as seguintes variáveis de configuração do Kubernetes. Certifique-se de definir service-type como load-balancer para acessar o aplicativo externamente.
# AKS configurations
%prod.quarkus.kubernetes.deployment-target=kubernetes
%prod.quarkus.kubernetes.service-type=load-balancer
Configuração de imagem de contêiner
Como uma tecnologia nativa da nuvem, o Quarkus suporta a geração de imagens de contêiner OCI compatíveis com Docker e Podman. Adicione as seguintes variáveis de imagem de contêiner. Substitua os valores de <LOGIN_SERVER_VALUE> e <USER_NAME_VALUE> pelos valores dos valores reais das ${LOGIN_SERVER} variáveis e ${USER_NAME} ambiente, respectivamente.
# Container Image Build
%prod.quarkus.container-image.build=true
%prod.quarkus.container-image.registry=<LOGIN_SERVER_VALUE>
%prod.quarkus.container-image.group=<USER_NAME_VALUE>
%prod.quarkus.container-image.name=todo-quarkus-aks
%prod.quarkus.container-image.tag=1.0
Crie a imagem do contêiner e envie-a para o ACR
Agora, use o seguinte comando para criar o próprio aplicativo. Este comando usa as extensões Kubernetes e Jib para criar a imagem do contêiner.
quarkus build --no-tests
A saída deve terminar com BUILD SUCCESS. Os arquivos de manifesto do Kubernetes são gerados em target/kubernetes, conforme mostrado no exemplo a seguir:
tree target/kubernetes
target/kubernetes
├── kubernetes.json
└── kubernetes.yml
0 directories, 2 files
Você pode verificar se a imagem do contêiner também é gerada usando docker ou podman linha de comando (CLI). A saída é semelhante ao exemplo a seguir:
docker images | grep todo
<LOGIN_SERVER_VALUE>/<USER_NAME_VALUE>/todo-quarkus-aks 1.0 b13c389896b7 18 minutes ago 420MB
Envie as imagens de contêiner para ACR usando o seguinte 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
O resultado deverá ter um aspeto semelhante ao seguinte exemplo:
The push refers to repository [<LOGIN_SERVER_VALUE>/<USER_NAME_VALUE>/todo-quarkus-aks]
dfd615499b3a: Pushed
56f5cf1aa271: Pushed
4218d39b228e: Pushed
b0538737ed64: Pushed
d13845d85ee5: Pushed
60609ec85f86: Pushed
1.0: digest: sha256:0ffd70d6d5bb3a4621c030df0d22cf1aa13990ca1880664d08967bd5bab1f2b6 size: 1995
Agora que você enviou o aplicativo para o ACR, você pode dizer ao AKS para executar o aplicativo.
Implantar o aplicativo Quarkus no AKS
As etapas nesta seção mostram como executar o aplicativo de exemplo Quarkus nos recursos do Azure que você criou.
Use kubectl apply para implantar o aplicativo Quarkus no AKS
Implante os recursos do Kubernetes usando kubectl na linha de comando, conforme mostrado no exemplo a seguir:
kubectl apply -f target/kubernetes/kubernetes.yml -n ${AKS_NS}
A saída deve ser semelhante ao exemplo a seguir:
deployment.apps/quarkus-todo-demo-app-aks created
Verifique se o aplicativo está em execução usando o seguinte comando:
kubectl -n $AKS_NS get pods
Se o valor do campo mostrar algo diferente de Running, solucione e resolva o problema antes de STATUS continuar. Pode ser útil examinar os logs do pod usando o seguinte comando:
kubectl -n $AKS_NS logs $(kubectl -n $AKS_NS get pods | grep quarkus-todo-demo-app-aks | cut -d " " -f1)
Obtenha o EXTERNAL-IP para acessar o aplicativo Todo usando o seguinte comando:
kubectl get svc -n ${AKS_NS}
A saída deve ser semelhante ao exemplo a seguir:
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
Você pode usar o seguinte comando para salvar o valor de em uma variável de EXTERNAL-IP ambiente como uma URL totalmente qualificada:
export QUARKUS_URL=http://$(kubectl get svc -n ${AKS_NS} | grep quarkus-todo-demo-app-aks | cut -d " " -f10)
echo $QUARKUS_URL
Abra um novo navegador da Web com o valor de ${QUARKUS_URL}. Em seguida, adicione um novo item todo com o texto Deployed the Todo app to AKS. Além disso, selecione o Introduction to Quarkus Todo App item como concluído.
Acesse a API RESTful (/api) para obter todos os itens de todo armazenados no banco de dados PostgreSQL do Azure, conforme mostrado no exemplo a seguir:
curl --verbose ${QUARKUS_URL}/api | jq .
A saída deve ser semelhante ao exemplo a seguir:
* 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
}
]
Verifique se o banco de dados foi atualizado usando o Azure Cloud Shell
Abra o Azure Cloud Shell no portal do Azure selecionando o ícone do Cloud Shell , conforme mostrado na captura de tela a seguir:
Execute o seguinte comando localmente e cole o resultado no Azure Cloud Shell:
echo psql --host=${DB_SERVER_NAME}.postgres.database.azure.com --port=5432 --username=quarkus@${DB_SERVER_NAME} --dbname=todo
Quando for solicitada a senha, use o valor usado quando criou o banco de dados.
Use a seguinte consulta para obter todos os itens de todo:
select * from todo;
A saída deve ser semelhante ao exemplo a seguir e deve incluir os mesmos itens na GUI do aplicativo Todo mostrada anteriormente:
Se você vir MORE na saída, digite q para sair do pager.
Digite \q para sair do psql programa e retornar ao Cloud Shell.
Clean up resources (Limpar recursos)
Para evitar cobranças do Azure, você deve limpar recursos desnecessários. Quando o cluster não for mais necessário, use o comando az group delete para remover o grupo de recursos, o serviço de contêiner, o registro de contêiner e todos os recursos relacionados.
git reset --hard
docker rmi ${TODO_QUARKUS_TAG}:1.0
docker rmi postgres
az group delete --name $RESOURCE_GROUP_NAME --yes --no-wait
Você também pode querer usar docker rmi para excluir as imagens postgres de contêiner e testcontainers geradas pelo modo de desenvolvimento do Quarkus.