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

Nota

Os planos Basic, Standard e Enterprise serão preteridos a partir de meados de março de 2025, com um período de aposentadoria de 3 anos. Recomendamos a transição para os Aplicativos de Contêiner do Azure. Para obter mais informações, consulte o anúncio de aposentadoria do Azure Spring Apps.

O plano de consumo padrão e dedicado será preterido a partir de 30 de setembro de 2024, com um desligamento completo após seis meses. Recomendamos a transição para os Aplicativos de Contêiner do Azure. Para obter mais informações, consulte Migrar consumo padrão e plano dedicado do Azure Spring Apps para Aplicativos de Contêiner do Azure.

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 da Chave, que corresponde ao domínio personalizado a ser usado para estabelecer o ouvinte HTTPS. Para obter mais informações, consulte Tutorial: Importar um certificado no Cofre de Chaves do Azure.

Configurar o Gateway de Aplicativo para Aplicativos Azure Spring

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 Gateway de Aplicativo na frente do Azure Spring Apps, use as etapas a seguir.

1. Siga as instruções em Implantar o Azure Spring Apps em uma rede virtual.
2. Siga as instruções em Acessar seu aplicativo em uma rede privada.
3. 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.
4. 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.
5. Implante o Application Gateway em uma rede virtual configurada de acordo com a lista a seguir:
   • Use o Azure Spring Apps no pool de back-end, referenciado pelo domínio sufixo 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.
6. 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'

Iniciar sessão no Azure

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

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.

Usar um certificado autoassinado

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 unirá a mesma rede virtual ou a 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 createo , e também crie um endereço IP público como o 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 aplicativo

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

Atualize as configurações HTTP para usar o nome de domínio público como o nome de host em vez do sufixo de domínio com ".private.azuremicroservices.io" para enviar tráfego para o Azure Spring Apps com.

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

Usar um certificado autoassinado

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

Para permitir a lista do certificado, primeiro busque a parte pública dele no Cofre da Chave 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

A saída indica o status íntegro 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 registro CNAME ou 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

• Solução de problemas do Azure Spring Apps na VNET
• Responsabilidades do cliente para executar aplicativos Azure Spring em VNET