Compartir a través de

Instalar AGIC mediante una nueva implementación de Application Gateway

En las instrucciones de este artículo se supone que desea instalar el controlador de entrada de Application Gateway (AGIC) en un entorno que no tiene componentes preexistentes.

Sugerencia

Considere Puerta de enlace de aplicaciones para contenedores como solución de entrada de Kubernetes. Para obtener más información, consulte Inicio rápido: Implementación de controlador de ALB para Puerta de enlace de aplicaciones para contenedores.

Instalar herramientas de línea de comandos necesarias

Se recomienda usar Azure Cloud Shell para todas las operaciones de línea de comandos de este artículo. Para abrir Cloud Shell, seleccione el botón Iniciar Cloud Shell.

Como alternativa, abra Cloud Shell desde Azure Portal seleccionando su icono.

Icono de Azure PowerShell en el portal

La instancia de Cloud Shell ya tiene todas las herramientas necesarias. Si decide usar otro entorno, asegúrese de que estén instaladas las herramientas de línea de comandos siguientes:

Creación de una identidad

Siga estos pasos para crear un objeto de entidad de servicio de Microsoft Entra.

  1. Cree una entidad de servicio de Active Directory, que incluye un rol de control de acceso basado en roles (RBAC) de Azure:

    az ad sp create-for-rbac --role Contributor --scopes /subscriptions/mySubscriptionID -o json > auth.json
appId=$(jq -r ".appId" auth.json)
password=$(jq -r ".password" auth.json)

    Registre los valores appId y password de la salida JSON. Los usará en los siguientes pasos.

  2. Use el valor appId del resultado del comando anterior para obtener el id de la nueva entidad de servicio:

    objectId=$(az ad sp show --id $appId --query "id" -o tsv)

    La salida de este comando es objectId. Registre este valor, ya que lo usará en el paso siguiente.

  3. Cree el archivo de parámetros que usará en la implementación de la plantilla de Azure Resource Manager (plantilla de ARM):

    cat <<EOF > parameters.json
{
  "aksServicePrincipalAppId": { "value": "$appId" },
  "aksServicePrincipalClientSecret": { "value": "$password" },
  "aksServicePrincipalObjectId": { "value": "$objectId" },
  "aksEnableRBAC": { "value": false }
}
EOF

    Para implementar un clúster habilitado para RBAC de Kubernetes, establezca aksEnableRBAC en true.

Implementación de componentes

El procedimiento siguiente agrega estos componentes a la suscripción:

Para implementar los componentes:

  1. Descargue la plantilla de ARM:

    wget https://raw.githubusercontent.com/Azure/application-gateway-kubernetes-ingress/master/deploy/azuredeploy.json -O template.json

  2. Implemente la plantilla de ARM mediante la CLI de Azure y modifíquela según sea necesario. La implementación puede tardar hasta 5 minutos.

    resourceGroupName="MyResourceGroup"
location="westus2"
deploymentName="ingress-appgw"

# create a resource group
az group create -n $resourceGroupName -l $location

# modify the template as needed
az deployment group create \
        -g $resourceGroupName \
        -n $deploymentName \
        --template-file template.json \
        --parameters parameters.json

  3. Una vez finalizada la implementación, descargue la salida de implementación en un archivo denominado deployment-outputs.json:

    az deployment group show -g $resourceGroupName -n $deploymentName --query "properties.outputs" -o json > deployment-outputs.json

Configurar AGIC

Con las instrucciones de la sección anterior, ha creado y configurado un nuevo clúster de AKS y una implementación de Application Gateway. Ya está listo para implementar una aplicación de ejemplo y un controlador de entrada en la nueva infraestructura de Kubernetes.

Configuración de las credenciales de Kubernetes

Para los pasos siguientes, debe configurar el comando kubectl, que usará para conectarse al nuevo clúster de Kubernetes. Cloud Shell ya tiene kubectl instalado. Usará az (CLI de Azure) para obtener credenciales para Kubernetes.

Obtenga las credenciales de la instancia de AKS recién implementada. Para obtener más información sobre los siguientes comandos, consulte Usar Azure RBAC para la autorización de Kubernetes con kubectl.

# use the deployment-outputs.json file created after deployment to get the cluster name and resource group name
aksClusterName=$(jq -r ".aksClusterName.value" deployment-outputs.json)
resourceGroupName=$(jq -r ".resourceGroupName.value" deployment-outputs.json)

az aks get-credentials --resource-group $resourceGroupName --name $aksClusterName

Instalación del identificador de carga de trabajo de Microsoft Entra

El identificador de carga de trabajo de Microsoft Entra proporciona acceso basado en tokens a Azure Resource Manager.

El identificador de carga de trabajo de Microsoft Entra agrega los siguientes componentes al clúster de Kubernetes:

Para instalar el identificador de carga de trabajo de Microsoft Entra en el clúster, use uno de los siguientes comandos:

  • Clúster de AKS habilitado para RBAC de Kubernetes:

    kubectl create -f https://raw.githubusercontent.com/Azure/aad-pod-identity/master/deploy/infra/deployment-rbac.yaml

  • Clúster de AKS deshabilitado para RBAC de Kubernetes:

    kubectl create -f https://raw.githubusercontent.com/Azure/aad-pod-identity/master/deploy/infra/deployment.yaml

Adición del repositorio de Helm

Helm es un administrador de paquetes para Kubernetes. Se usa para instalar el paquete application-gateway-kubernetes-ingress.

Si usa Cloud Shell, no es necesario instalar Helm. Cloud Shell viene con la versión 3 de Helm. Ejecute uno de los siguientes comandos para agregar el repositorio de Helm de AGIC:

  • Clúster de AKS habilitado para RBAC de Kubernetes:

    kubectl create serviceaccount --namespace kube-system tiller-sa
kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller-sa
helm init --tiller-namespace kube-system --service-account tiller-sa

  • Clúster de AKS deshabilitado para RBAC de Kubernetes:

    helm init

Instalar el gráfico de Helm del controlador de entrada

  1. Use el archivo deployment-outputs.json que creó anteriormente para crear las siguientes variables:

    applicationGatewayName=$(jq -r ".applicationGatewayName.value" deployment-outputs.json)
resourceGroupName=$(jq -r ".resourceGroupName.value" deployment-outputs.json)
subscriptionId=$(jq -r ".subscriptionId.value" deployment-outputs.json)
identityClientId=$(jq -r ".identityClientId.value" deployment-outputs.json)
identityResourceId=$(jq -r ".identityResourceId.value" deployment-outputs.json)

  2. Descargue helm-config.yaml, que configura AGIC:

    wget https://raw.githubusercontent.com/Azure/application-gateway-kubernetes-ingress/master/docs/examples/sample-helm-config.yaml -O helm-config.yaml

    O copie el siguiente archivo YAML:

    # This file contains the essential configs for the ingress controller helm chart

# Verbosity level of the App Gateway Ingress Controller
verbosityLevel: 3

################################################################################
# Specify which application gateway the ingress controller will manage
#
appgw:
    subscriptionId: <subscriptionId>
    resourceGroup: <resourceGroupName>
    name: <applicationGatewayName>

    # Setting appgw.shared to "true" will create an AzureIngressProhibitedTarget CRD.
    # This prohibits AGIC from applying config for any host/path.
    # Use "kubectl get AzureIngressProhibitedTargets" to view and change this.
    shared: false

################################################################################
# Specify which kubernetes namespace the ingress controller will watch
# Default value is "default"
# Leaving this variable out or setting it to blank or empty string would
# result in Ingress Controller observing all accessible namespaces.
#
# kubernetes:
#   watchNamespace: <namespace>

################################################################################
# Specify the authentication with Azure Resource Manager
#
# Two authentication methods are available:
# - Option 1: AAD-Pod-Identity (https://github.com/Azure/aad-pod-identity)
armAuth:
    type: aadPodIdentity
    identityResourceID: <identityResourceId>
    identityClientID:  <identityClientId>

## Alternatively you can use Service Principal credentials
# armAuth:
#    type: servicePrincipal
#    secretJSON: <<Generate this value with: "az ad sp create-for-rbac --subscription <subscription-uuid> --role Contributor --sdk-auth | base64 -w0" >>

################################################################################
# Specify if the cluster is Kubernetes RBAC enabled or not
rbac:
    enabled: false # true/false

# Specify aks cluster related information. THIS IS BEING DEPRECATED.
aksClusterConfiguration:
    apiServerAddress: <aks-api-server-address>

  3. Edite el archivo recién descargado helm-config.yaml y rellene las secciones de appgw y armAuth:

    sed -i "s|<subscriptionId>|${subscriptionId}|g" helm-config.yaml
sed -i "s|<resourceGroupName>|${resourceGroupName}|g" helm-config.yaml
sed -i "s|<applicationGatewayName>|${applicationGatewayName}|g" helm-config.yaml
sed -i "s|<identityResourceId>|${identityResourceId}|g" helm-config.yaml
sed -i "s|<identityClientId>|${identityClientId}|g" helm-config.yaml

    Nota

    Si va a implementar en una nube soberana (por ejemplo, Azure Government), debe agregar el parámetro de configuración appgw.environment y establecerlo en el valor adecuado.

    A continuación, se muestran los valores:

    • verbosityLevel: establece el nivel de detalle de la infraestructura de registro de AGIC. Para conocer los valores posibles, consulte Niveles de registro.
    • appgw.environment: establece el entorno de nube. Valores posibles: AZURECHINACLOUD, AZUREGERMANCLOUD, AZUREPUBLICCLOUD, AZUREUSGOVERNMENTCLOUD.
    • appgw.subscriptionId: el identificador de suscripción de Azure en el que reside la instancia de Application Gateway. Ejemplo: aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e.
    • appgw.resourceGroup: nombre del grupo de recursos de Azure en el que creó la implementación de Application Gateway. Ejemplo: app-gw-resource-group.
    • appgw.name: nombre de la implementación de Application Gateway. Ejemplo: applicationgatewayd0f0.
    • appgw.shared: marca booleana que tiene como valor predeterminado false. Establézcalo en true si necesita una implementación de Application Gateway compartida.
    • kubernetes.watchNamespace: especifica el espacio de nombres que debe observar AGIC. El espacio de nombres puede ser un valor de cadena único o una lista separada por comas de espacios de nombres.
    • armAuth.type: podría ser aadPodIdentity o servicePrincipal.
    • armAuth.identityResourceID: identificador de recurso de la identidad administrada de Azure.
    • armAuth.identityClientID: id. de cliente de la identidad.
    • armAuth.secretJSON: solo se necesita cuando se elige una entidad de servicio como tipo de secreto (es decir, cuando se establece armAuth.type en servicePrincipal).

    Nota

    Ha creado los valores identityResourceID y identityClientID durante los pasos anteriores para la implementación de componentes. Puede obtenerlos de nuevo mediante el siguiente comando:

    az identity show -g <resource-group> -n <identity-name>

    En el comando, <resource-group> es el grupo de recursos de la implementación de Application Gateway. El marcador de posición <identity-name> es el nombre de la identidad creada. Puede enumerar todas las identidades de una suscripción determinada mediante az identity list.

  4. Instalar el paquete AGIC:

    helm install agic-controller oci://mcr.microsoft.com/azure-application-gateway/charts/ingress-azure --version 1.8.1 -f helm-config.yaml

Instalación de una aplicación de ejemplo

Ahora que ha instalado Application Gateway, AKS y AGIC, puede instalar una aplicación de ejemplo mediante Azure Cloud Shell:

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: aspnetapp
  labels:
    app: aspnetapp
spec:
  containers:
  - image: "mcr.microsoft.com/dotnet/samples:aspnetapp"
    name: aspnetapp-image
    ports:
    - containerPort: 8080
      protocol: TCP

---

apiVersion: v1
kind: Service
metadata:
  name: aspnetapp
spec:
  selector:
    app: aspnetapp
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

---

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: aspnetapp
  annotations:
    kubernetes.io/ingress.class: azure/application-gateway
spec:
  rules:
  - http:
      paths:
      - path: /
        pathType: Exact
        backend:
          service:
            name: aspnetapp
            port:
              number: 80
        pathType: Exact
EOF

También puede:

  • Descargar el archivo YAML anterior:

    curl https://raw.githubusercontent.com/Azure/application-gateway-kubernetes-ingress/master/docs/examples/aspnetapp.yaml -o aspnetapp.yaml

  • Aplique el archivo YAML:

    kubectl apply -f aspnetapp.yaml

Contenido relacionado

  • Last updated on