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

Observação

Azure Spring Apps é o novo nome do serviço Azure Spring Cloud. Embora o serviço tenha um novo nome, você verá o nome antigo em alguns locais por um tempo enquanto trabalhamos para atualizar ativos como capturas de tela, vídeos e diagramas.

Este artigo se aplica ao: ✔️ nível Básico/Standard ✔️ nível Enterprise

Este artigo explica como expor aplicativos à Internet usando o Gateway de Aplicativo. Quando uma instância do serviço do Azure Spring Apps é implantada em sua rede virtual, os aplicativos na instância do serviço só podem ser acessados na rede privada. Para tornar os aplicativos acessíveis na Internet, você precisa ter a integração 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 .private.azuremicroservices.io padrão. Para obter mais informações, confira Implantar o Azure Spring Apps em uma rede virtual
• Um domínio personalizado a ser usado para acessar o aplicativo.
• Um certificado, armazenado no Key Vault, 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 Azure Key Vault.

Configurar o Gateway de Aplicativo para o Azure Spring Apps

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

Para configurar o Gateway de Aplicativo na frente do Azure Spring Apps, siga 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 domínio de sua escolha e armazene-o no Azure Key Vault. Para obter mais informações, consulte Tutorial: Importar um certificado no Azure Key Vault.
4. Configure um domínio personalizado e um certificado correspondente no Key Vault em um aplicativo implantado no Azure Spring Apps. Para obter mais informações, confira Tutorial: Mapear um domínio personalizado existente para o Azure Spring Apps.
5. Implante o Gateway de Aplicativo em uma rede virtual configurada de acordo com a seguinte lista:
   • Use o Azure Spring Apps no pool de back-end, referenciado pelo domínio com sufixo private.azuremicroservices.io.
   • Inclua um ouvinte HTTPS usando o mesmo certificado do Azure Key Vault.
   • Prepare a rede virtual com configurações de HTTP que usam o nome de domínio personalizado configurado no Azure Spring Apps em vez do domínio com sufixo private.azuremicroservices.io.
6. Configure seu DNS público para apontar para o Gateway de Aplicativo.

Definir variáveis

Em seguida, use os seguintes comandos para definir variáveis para o grupo de recursos e a rede virtual que você criou conforme orientado em Implantar o Azure Spring Apps em uma rede virtual. Personalize os valores com base em seu ambiente real. Ao definir SPRING_APP_PRIVATE_FQDN, remova do https:// 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'

Entrar 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

Adquirir 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 Azure Key Vault. Para obter mais informações, consulte Tutorial: Importar um certificado no Azure Key Vault. Certifique-se de que o certificado inclua toda a cadeia de certificados.

Usar um certificado autoassinado

Quando você precisar de um certificado autoassinado para teste ou desenvolvimento, terá que 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ê vai expor o aplicativo. Ao criar um certificado autoassinado por meio do Azure Key Vault, você pode usar o portal do Microsoft 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 o JSON da política, conforme mostrado no exemplo a seguir, indicando 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 terminar de atualizar a política JSON (consulte Atualizar política de certificado), você pode criar um certificado autoassinado no Azure Key Vault 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 escutar esse nome do host e fazer isso 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 da rede

O Gateway de Aplicativo do Azure que será criado ingressará na mesma rede virtual que a instância de serviço do Azure Spring Apps ou na rede virtual emparelhada com a instância de serviço do Azure Spring Apps. Primeiro, crie uma nova sub-rede para o Gateway de Aplicativo na rede virtual usando az network vnet subnet create. Crie também um endereço IP público como o Front-end do gateway de aplicativo 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 Gateway de Aplicativo precisará poder de acessar o Azure Key Vault 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 posteriormente para conceder direitos para acessar o 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 a política no Azure Key Vault

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

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 nome de domínio totalmente qualificado (FQDN) privado do 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 de Chaves usando a ID Secreta do certificado. Em seguida, atualize a configuração de HTTP usando az network application-gateway http-settings update para usar o nome do 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 que o Azure crie o gateway de aplicativo.

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

Usar um certificado assinado publicamente

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

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 de HTTP para usar o nome de domínio público como o nome do host em vez do domínio com sufixo ".private.azuremicroservices.io" para enviar tráfego para o Azure Spring Apps. Considerando que um certificado autoassinado é usado, ele precisará ser listado com permissões na lista de Configurações HTTP do Gateway de Aplicativo.

Para incluir na lista de permitidos o certificado, primeiro busque a parte pública dele no Azure 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 no Gateway de Aplicativo 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 de 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

Verificar a implantação do Gateway de Aplicativo

Depois de criado, verifique a integridade do back-end usando o comando a seguir. A saída desse comando permite que você determine se o gateway de aplicativo atinge seu aplicativo por meio de seu FQDN particular.

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

A saída indica o status da integridade 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 Gateway de Aplicativo usando um registro CNAME ou A. Você pode encontrar o endereço público do Gateway de Aplicativo 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óximas etapas

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