Exponha aplicativos com TLS de ponta a ponta em uma rede virtual

Nota

Os planos Basic, Standarde Enterprise entraram em um período de aposentadoria em 17 de março de 2025. Para obter mais informações, consulte o anúncio de aposentadoria do Azure Spring Apps.

Este artigo aplica-se a:✅ Basic/Standard ✅ Enterprise

Este artigo explica como expor aplicativos à Internet usando o Application Gateway. Quando uma instância de serviço do Azure Spring Apps é implantada em sua rede virtual, os aplicativos na instância de serviço só são acessíveis na rede privada. Para tornar os aplicativos acessíveis na Internet, você precisa integrar com o Gateway de Aplicativo do Azure.

Pré-requisitos

CLI do Azure versão 2.0.4 ou posterior.
Uma instância de serviço do Azure Spring Apps implantada em uma rede virtual com um aplicativo acessível pela rede privada usando o sufixo de domínio padrão .private.azuremicroservices.io . Para obter mais informações, consulte Implantar aplicativos Azure Spring em uma rede virtual
Um domínio personalizado a ser usado para acessar o aplicativo.
Um certificado, armazenado no Cofre de Chaves, que corresponde ao domínio personalizado a ser utilizado para configurar o ouvinte HTTPS. Para obter mais informações, consulte Tutorial: Importar um certificado no Cofre de Chaves do Azure.

Configurar o Gateway de Aplicações para o Azure Spring Apps

Recomendamos que o nome de domínio, conforme visto pelo navegador, seja o mesmo que o nome de host que o Gateway de Aplicativo usa para direcionar o tráfego para o back-end do Azure Spring Apps. Esta recomendação fornece a melhor experiência ao usar o Application Gateway para expor aplicativos hospedados no Azure Spring Apps e residentes em uma rede virtual. Se o domínio exposto pelo Application Gateway for diferente do domínio aceito pelo Azure Spring Apps, os cookies e as URLs de redirecionamento geradas (por exemplo) poderão ser quebrados. Para obter mais informações, consulte Preservação do nome do host.

Para configurar o Application Gateway à frente do Azure Spring Apps, use os seguintes passos.

Siga as instruções em Implantar o Azure Spring Apps em uma rede virtual.
Siga as instruções em Acessar seu aplicativo em uma rede privada.
Adquira um certificado para o seu domínio de escolha e armazene-o no Cofre de Chaves. Para obter mais informações, consulte Tutorial: Importar um certificado no Cofre de Chaves do Azure.
Configure um domínio personalizado e o certificado correspondente do Cofre da Chave em um aplicativo implantado no Azure Spring Apps. Para obter mais informações, consulte Tutorial: Mapear um domínio personalizado existente para o Azure Spring Apps.
Implante o Application Gateway em uma rede virtual configurada de acordo com a lista a seguir:
- Utilize o Azure Spring Apps na pool de back-end, referenciado pelo domínio sufixado com private.azuremicroservices.io.
- Inclua um ouvinte HTTPS usando o mesmo certificado do Cofre de Chaves.
- Configure a rede virtual com configurações HTTP que usam o nome de domínio personalizado configurado no Azure Spring Apps em vez do sufixo de domínio com private.azuremicroservices.io.
Configure seu DNS público para apontar para o Application Gateway.

Definir variáveis

Em seguida, use os comandos a seguir para definir variáveis para o grupo de recursos e a rede virtual que você criou, conforme indicado em Implantar Aplicativos Azure Spring em uma rede virtual. Personalize os valores com base no seu ambiente real. Quando você definir SPRING_APP_PRIVATE_FQDN, remova https:// do URI.

export SUBSCRIPTION='subscription-id'
export RESOURCE_GROUP='my-resource-group'
export LOCATION='eastus'
export SPRING_CLOUD_NAME='name-of-spring-cloud-instance'
export APPNAME='name-of-app-in-azure-spring-apps'
export SPRING_APP_PRIVATE_FQDN='$APPNAME.private.azuremicroservices.io'
export VIRTUAL_NETWORK_NAME='azure-spring-apps-vnet'
export APPLICATION_GATEWAY_SUBNET_NAME='app-gw-subnet'
export APPLICATION_GATEWAY_SUBNET_CIDR='10.1.2.0/24'

Use o comando a seguir para entrar na CLI do Azure e escolher sua assinatura ativa.

az login
az account set --subscription $SUBSCRIPTION

Adquira um certificado

Usar um certificado assinado publicamente
Usar um certificado autoassinado

Para implantações de produção, você provavelmente usará um certificado assinado publicamente. Nesse caso, importe o certificado no Cofre da Chave do Azure. Para obter mais informações, consulte Tutorial: Importar um certificado no Cofre de Chaves do Azure. Verifique se o certificado inclui toda a cadeia de certificados.

Quando você precisa de um certificado autoassinado para teste ou desenvolvimento, você precisa criá-lo. Você também precisará garantir que a lista de "Nomes Alternativos de Assunto" no certificado contenha o nome de domínio no qual você exporá o aplicativo. Ao criar um certificado autoassinado por meio do Cofre da Chave do Azure, você pode fazê-lo por meio do portal do Azure. Como alternativa, ao usar a CLI do Azure, você precisará de um arquivo JSON de política.

Para solicitar a política padrão, use o seguinte comando:

az keyvault certificate get-default-policy

Em seguida, adapte a política JSON como mostrado no exemplo a seguir, indicando o subject e SubjectAlternativeNames:

{
  // ...
    "subject": "C=US, ST=WA, L=Redmond, O=Contoso, OU=Contoso HR, CN=myapp.mydomain.com",
    "subjectAlternativeNames": {
        "dnsNames": [
            "myapp.mydomain.com",
            "*.myapp.mydomain.com"
        ],
        "emails": [
            "hello@contoso.com"
        ],
          "upns": []
      }
  // ...
}

Depois de concluir a atualização da política JSON (consulte Atualizar política de certificado), você pode criar um certificado autoassinado no Cofre da Chave usando os seguintes comandos:

export KV_NAME='name-of-key-vault'
export CERT_NAME_IN_KEY_VAULT='name-of-certificate-in-key-vault'

az keyvault certificate create \
    --vault-name $KV_NAME \
    --name $CERT_NAME_IN_KEY_VAULT \
    --policy "$KV_CERT_POLICY"

Configurar o nome de domínio público no Azure Spring Apps

O tráfego entrará no aplicativo implantado no Azure Spring Apps usando o nome de domínio público. Para configurar seu aplicativo para ouvir esse nome de host e fazê-lo por HTTPS, use os seguintes comandos para adicionar um domínio personalizado ao seu aplicativo:

export KV_NAME='name-of-key-vault'
export KV_RG='resource-group-name-of-key-vault'
export CERT_NAME_IN_AZURE_SPRING_APPS='name-of-certificate-in-Azure-Spring-Apps'
export CERT_NAME_IN_KEY_VAULT='name-of-certificate-with-intermediaries-in-key-vault'
export DOMAIN_NAME=myapp.mydomain.com

# provide permissions to Azure Spring Apps to read the certificate from Key Vault:
export VAULTURI=$(az keyvault show \
    --resource-group $KV_RG \
    --name $KV_NAME \
    --query properties.vaultUri \
    --output tsv)

# get the object id for the Azure Spring Apps Domain-Management Service Principal:
export ASADM_OID=$(az ad sp show \
    --id 03b39d0f-4213-4864-a245-b1476ec03169 \
    --query objectId \
    --output tsv)

# allow this Service Principal to read and list certificates and secrets from Key Vault:
az keyvault set-policy \
    --resource-group $KV_RG \
    --name $KV_NAME \
    --object-id $ASADM_OID \
    --certificate-permissions get list \
    --secret-permissions get list

# add custom domain name and configure TLS using the certificate:
az spring certificate add \
    --resource-group $RESOURCE_GROUP \
    --service $SPRING_CLOUD_NAME \
    --name $CERT_NAME_IN_AZURE_SPRING_APPS \
    --vault-certificate-name $CERT_NAME_IN_KEY_VAULT \
    --vault-uri $VAULTURI
az spring app custom-domain bind \
    --resource-group $RESOURCE_GROUP \
    --service $SPRING_CLOUD_NAME \
    --domain-name $DOMAIN_NAME \
    --certificate $CERT_NAME_IN_AZURE_SPRING_APPS \
    --app $APPNAME

Criar recursos de rede

O Gateway de Aplicativo do Azure a ser criado entrará na mesma rede virtual ou numa rede virtual emparelhada à instância de serviço do Azure Spring Apps. Primeiro, crie uma nova sub-rede para o Application Gateway na rede virtual usando az network vnet subnet create, e também crie um endereço IP público como frontend do Application Gateway usando az network public-ip create.

export APPLICATION_GATEWAY_PUBLIC_IP_NAME='app-gw-public-ip'
az network vnet subnet create \
    --name $APPLICATION_GATEWAY_SUBNET_NAME \
    --resource-group $RESOURCE_GROUP \
    --vnet-name $VIRTUAL_NETWORK_NAME \
    --address-prefix $APPLICATION_GATEWAY_SUBNET_CIDR
az network public-ip create \
    --resource-group $RESOURCE_GROUP \
    --location $LOCATION \
    --name $APPLICATION_GATEWAY_PUBLIC_IP_NAME \
    --allocation-method Static \
    --sku Standard

Criar uma identidade gerenciada para o Application Gateway

O Application Gateway precisará ser capaz de acessar o Cofre da Chave para ler o certificado. Para fazer isso, ele usará uma identidade gerenciada atribuída pelo usuário. Crie a identidade gerenciada usando o seguinte comando:

export APPGW_IDENTITY_NAME='name-for-appgw-managed-identity'
az identity create \
    --resource-group $RESOURCE_GROUP \
    --name $APPGW_IDENTITY_NAME

Em seguida, busque o objectId para a identidade gerenciada, pois ele será usado mais tarde para conceder direitos de acesso ao certificado no Cofre da Chave:

export APPGW_IDENTITY_CLIENTID=$(az identity show \
    --resource-group $RESOURCE_GROUP \
    --name $APPGW_IDENTITY_NAME \
    --query clientId \
    --output tsv)
export APPGW_IDENTITY_OID=$(az ad sp show \
    --id $APPGW_IDENTITY_CLIENTID \
    --query objectId \
    --output tsv)

Definir política no Cofre da Chave

Configure o Cofre da Chave usando o seguinte comando para que a identidade gerenciada do Application Gateway tenha permissão para acessar o certificado armazenado no Cofre da Chave:

az keyvault set-policy \
    --name $KV_NAME \
    --resource-group $KV_RG \
    --object-id $APPGW_IDENTITY_OID \
    --secret-permissions get list \
    --certificate-permissions get list

Criar Gateway de Aplicações

Crie um gateway de aplicativo usando az network application-gateway create e especifique o FQDN (nome de domínio privado totalmente qualificado) do seu aplicativo como servidores no pool de back-end. Certifique-se de usar a identidade gerenciada atribuída pelo usuário e apontar para o certificado no Cofre da Chave usando a ID Secreta do certificado. Em seguida, atualize a configuração HTTP usando az network application-gateway http-settings update para usar o nome de host público.

export APPGW_NAME='name-for-application-gateway'

export KEYVAULT_SECRET_ID_FOR_CERT=$(az keyvault certificate show \
    --name $CERT_NAME_IN_KEY_VAULT \
    --vault-name $KV_NAME \
    --query sid \
    --output tsv)

az network application-gateway create \
    --name $APPGW_NAME \
    --resource-group $RESOURCE_GROUP \
    --location $LOCATION \
    --capacity 2 \
    --sku Standard_v2 \
    --frontend-port 443 \
    --http-settings-cookie-based-affinity Disabled \
    --http-settings-port 443 \
    --http-settings-protocol Https \
    --public-ip-address $APPLICATION_GATEWAY_PUBLIC_IP_NAME \
    --vnet-name $VIRTUAL_NETWORK_NAME \
    --subnet $APPLICATION_GATEWAY_SUBNET_NAME \
    --servers $SPRING_APP_PRIVATE_FQDN \
    --key-vault-secret-id $KEYVAULT_SECRET_ID_FOR_CERT \
    --identity $APPGW_IDENTITY_NAME

Pode levar até 30 minutos para o Azure criar o gateway de aplicativo.

Atualize as configurações HTTP para usar o nome de domínio no back-end

Usar um certificado assinado publicamente
Usar um certificado autoassinado

az network application-gateway http-settings update \
    --resource-group $RESOURCE_GROUP \
    --gateway-name $APPGW_NAME \
    --host-name-from-backend-pool false \
    --host-name $DOMAIN_NAME \
    --name appGatewayBackendHttpSettings

Atualize as configurações HTTP para usar o nome de domínio público como o nome de host, para enviar tráfego para o Azure Spring Apps, em vez do domínio sufixado com ".private.azuremicroservices.io". Dado que um certificado autoassinado é usado, ele precisará ser listado nas Configurações HTTP do Application Gateway.

Para adicionar à lista de permissões o certificado, primeiro obtenha a parte pública dele no Key Vault usando o seguinte comando:

az keyvault certificate download \
    --vault-name $KV_NAME \
    --name $CERT_NAME_IN_KEY_VAULT \
    --file ./selfsignedcert.crt \
    --encoding DER

Em seguida, carregue-o para o Application Gateway usando este comando:

az network application-gateway root-cert create \
    --resource-group $RG \
    --cert-file ./selfsignedcert.crt \
    --gateway-name $APPGW_NAME \
    --name MySelfSignedTrustedRootCert

Agora você pode atualizar as Configurações HTTP para confiar no novo certificado raiz (autoassinado) usando este comando:

az network application-gateway http-settings update \
    --resource-group $RG \
    --gateway-name $APPGW_NAME \
    --host-name-from-backend-pool false \
    --host-name $DOMAIN_NAME \
    --name appGatewayBackendHttpSettings \
    --root-certs MySelfSignedTrustedRootCert

Verifique a implantação do Application Gateway

Depois de criado, verifique a integridade do back-end usando o comando a seguir. A saída desse comando permite determinar se o gateway de aplicativo alcança seu aplicativo por meio de seu FQDN privado.

az network application-gateway show-backend-health \
    --name $APPGW_NAME \
    --resource-group $RESOURCE_GROUP

O resultado indica o estado saudável do pool de back-end, conforme mostrado no exemplo a seguir:

{
  "backendAddressPools": [
    {
      "backendHttpSettingsCollection": [
        {
          "servers": [
            {
              "address": "my-azure-spring-apps-hello-vnet.private.azuremicroservices.io",
              "health": "Healthy",
              "healthProbeLog": "Success. Received 200 status code",
              "ipConfiguration": null
            }
          ]
        }
      ]
    }
  ]
}

Configurar o DNS e acessar o aplicativo

Agora, configure o DNS público para apontar para o Application Gateway usando um registo CNAME ou de tipo A. Você pode encontrar o endereço público do Application Gateway usando o seguinte comando:

az network public-ip show \
    --resource-group $RESOURCE_GROUP \
    --name $APPLICATION_GATEWAY_PUBLIC_IP_NAME \
    --query [ipAddress] \
    --output tsv

Agora você pode acessar o aplicativo usando o nome de domínio público.

Próximos passos

Feedback

Esta página foi útil?

Last updated on 2025-08-19