Control del tráfico de salida de los nodos de clúster en Azure Kubernetes Service (AKS)Control egress traffic for cluster nodes in Azure Kubernetes Service (AKS)

• 11/09/2020
• Tiempo de lectura: 24 minutos
• • p
  • o

En este artículo se proporcionan los detalles necesarios que permiten proteger el tráfico de salida desde Azure Kubernetes Service (AKS).This article provides the necessary details that allow you to secure outbound traffic from your Azure Kubernetes Service (AKS). Contiene los requisitos del clúster para una implementación de AKS base y requisitos adicionales para características y complementos opcionales.It contains the cluster requirements for a base AKS deployment, and additional requirements for optional addons and features. Al final, se proporciona un ejemplo de cómo configurar estos requisitos con Azure Firewall.An example will be provided at the end on how to configure these requirements with Azure Firewall. Pero puede aplicar esta información a cualquier método o dispositivo de restricción de salida.However, you can apply this information to any outbound restriction method or appliance.

Información previaBackground

Los clústeres de AKS se implementan en una red virtual.AKS clusters are deployed on a virtual network. Esta red puede ser administrada (creada por AKS) o personalizada (configurada previamente por el usuario).This network can be managed (created by AKS) or custom (pre-configured by the user beforehand). En cualquier caso, el clúster tiene dependencias de salida en servicios externos a esa red virtual (el servicio no tiene dependencias de entrada).In either case, the cluster has outbound dependencies on services outside of that virtual network (the service has no inbound dependencies).

Para fines operativos y de administración, los nodos de un clúster de AKS deben tener acceso a determinados puertos y nombres de dominio completo (FQDN).For management and operational purposes, nodes in an AKS cluster need to access certain ports and fully qualified domain names (FQDNs). Estos puntos de conexión son obligatorios para que los nodos se comuniquen con el servidor de API, o bien para descargar e instalar actualizaciones de seguridad de nodos y componentes principales de clúster de Kubernetes.These endpoints are required for the nodes to communicate with the API server, or to download and install core Kubernetes cluster components and node security updates. Por ejemplo, el clúster debe extraer imágenes de contenedor del sistema base desde el Registro de contenedor de Microsoft (MCR).For example, the cluster needs to pull base system container images from Microsoft Container Registry (MCR).

Las dependencias de salida de AKS se definen casi por completo mediante FQDN, que no tienen direcciones estáticas tras ellos.The AKS outbound dependencies are almost entirely defined with FQDNs, which don't have static addresses behind them. La falta de direcciones estáticas significa que no se pueden usar grupos de seguridad de red para bloquear el tráfico saliente desde un clúster de AKS.The lack of static addresses means that Network Security Groups can't be used to lock down the outbound traffic from an AKS cluster.

De forma predeterminada, los clústeres de AKS tienen acceso de salida a Internet ilimitado.By default, AKS clusters have unrestricted outbound (egress) internet access. Este nivel de acceso a la red permite que los nodos y servicios que ejecuta accedan a recursos externos según sea necesario.This level of network access allows nodes and services you run to access external resources as needed. Si desea restringir el tráfico de salida, es necesario el acceso a un número limitado de puertos y direcciones para mantener las tareas de mantenimiento del clúster en buen estado.If you wish to restrict egress traffic, a limited number of ports and addresses must be accessible to maintain healthy cluster maintenance tasks. La solución más sencilla para proteger las direcciones de salida consiste en usar un dispositivo de firewall que pueda controlar el tráfico saliente en función de los nombres de dominio.The simplest solution to securing outbound addresses lies in use of a firewall device that can control outbound traffic based on domain names. Azure Firewall, por ejemplo, puede restringir el tráfico saliente HTTP y HTTPS en función del FQDN de destino.Azure Firewall, for example, can restrict outbound HTTP and HTTPS traffic based on the FQDN of the destination. También puede configurar las reglas de seguridad y de firewall que prefiera para permitir estos puertos y direcciones necesarios.You can also configure your preferred firewall and security rules to allow these required ports and addresses.

Reglas de red de salida y FQDN necesarios para clústeres de AKSRequired outbound network rules and FQDNs for AKS clusters

Las siguientes reglas de red y FQDN o aplicación son obligatorias para un clúster de AKS; puede usarlas si quiere configurar una solución que no sea Azure Firewall.The following network and FQDN/application rules are required for an AKS cluster, you can use them if you wish to configure a solution other than Azure Firewall.

_ Las dependencias de dirección IP son para tráfico que no sea HTTP/HTTPS (tráfico TCP y UDP)._ IP Address dependencies are for non-HTTP/S traffic (both TCP and UDP traffic)

• Los puntos de conexión HTTP/HTTPS de FQDN se pueden colocar en el dispositivo de firewall.FQDN HTTP/HTTPS endpoints can be placed in your firewall device.
• Los puntos de conexión HTTP/HTTPS de carácter comodín son dependencias que pueden variar con el clúster de AKS en función de una serie de calificadores.Wildcard HTTP/HTTPS endpoints are dependencies that can vary with your AKS cluster based on a number of qualifiers.
• AKS usa un controlador de admisión para insertar el FQDN como una variable de entorno en todas las implementaciones en kube-system y gatekeeper-system, lo que garantiza que toda la comunicación del sistema entre los nodos y el servidor de API usa el FQDN del servidor de API y no su dirección IP.AKS uses an admission controller to inject the FQDN as an environment variable to all deployments under kube-system and gatekeeper-system, that ensures all system communication between nodes and API server uses the API server FQDN and not the API server IP.
• Si tiene una aplicación o solución que necesita comunicarse con el servidor de API, debe agregar una regla de red adicional para permitir la comunicación TCP con el puerto 443 de la dirección IP del servidor de API.If you have an app or solution that needs to talk to the API server, you must add an additional network rule to allow TCP communication to port 443 of your API server's IP.
• En raras ocasiones, si hay una operación de mantenimiento, es posible que cambie la dirección IP del servidor de API.On rare occasions, if there's a maintenance operation your API server IP might change. Las operaciones de mantenimiento planeado que pueden cambiar la dirección IP del servidor de API siempre se comunican con antelación.Planned maintenance operations that can change the API server IP are always communicated in advance.

Reglas de red obligatorias globales de AzureAzure Global required network rules

Las reglas de red obligatorias y las dependencias de dirección IP son las siguientes:The required network rules and IP address dependencies are:

Reglas de aplicación o FQDN obligatorias globales de AzureAzure Global required FQDN / application rules

Se requieren las siguientes reglas de aplicación / FQDN:The following FQDN / application rules are required:

Reglas de red obligatorias para Azure China 21VianetAzure China 21Vianet required network rules

Las reglas de red obligatorias y las dependencias de dirección IP son las siguientes:The required network rules and IP address dependencies are:

Reglas de aplicación o FQDN obligatorias para Azure China 21VianetAzure China 21Vianet required FQDN / application rules

Se requieren las siguientes reglas de aplicación / FQDN:The following FQDN / application rules are required:

Reglas de red obligatorias para Azure Gobierno de EE. UU.Azure US Government required network rules

Las reglas de red obligatorias y las dependencias de dirección IP son las siguientes:The required network rules and IP address dependencies are:

Reglas de aplicación o FQDN obligatorias para Azure Gobierno de EE. UU.Azure US Government required FQDN / application rules

Se requieren las siguientes reglas de aplicación / FQDN:The following FQDN / application rules are required:

Reglas opcionales de FQDN o aplicación para clústeres de AKSOptional recommended FQDN / application rules for AKS clusters

Las siguientes reglas de aplicación o FQDN son opcionales, pero se recomiendan para clústeres de AKS:The following FQDN / application rules are optional but recommended for AKS clusters:

Si decide bloquear o no permitir estos FQDN, los nodos solo recibirán actualizaciones del sistema operativo cuando realice una actualización de imagen de nodo o una actualización de clústeres.If you choose to block/not allow these FQDNs, the nodes will only receive OS updates when you do a node image upgrade or cluster upgrade.

Clústeres de AKS habilitados para GPUGPU enabled AKS clusters

Reglas de aplicación o FQDN obligatoriasRequired FQDN / application rules

Los clústeres de AKS que tienen GPU habilitado necesitan las reglas de aplicación / FQDN siguientes:The following FQDN / application rules are required for AKS clusters that have GPU enabled:

Grupos de nodos basados en Windows ServerWindows Server based node pools

Reglas de aplicación o FQDN obligatoriasRequired FQDN / application rules

Los grupos de nodos basados en Windows Server necesitan las reglas de aplicación/FQDN siguientes:The following FQDN / application rules are required for using Windows Server based node pools:

Complementos e integraciones de AKSAKS addons and integrations

Azure Monitor para contenedoresAzure Monitor for containers

Hay dos opciones para proporcionar a los contenedores acceso a Azure Monitor; puede permitir ServiceTag de Azure Monitor, o bien proporcionar acceso a las reglas de aplicación y FQDN necesarias.There are two options to provide access to Azure Monitor for containers, you may allow the Azure Monitor ServiceTag or provide access to the required FQDN/Application Rules.

Reglas de red obligatoriasRequired network rules

Se requieren las siguientes reglas de aplicación / FQDN:The following FQDN / application rules are required:

Reglas de aplicación o FQDN obligatoriasRequired FQDN / application rules

Los clústeres de AKS que tienen habilitado Azure Monitor para contenedores necesitan las reglas de aplicación / FQDN siguientes:The following FQDN / application rules are required for AKS clusters that have the Azure Monitor for containers enabled:

Azure Dev SpacesAzure Dev Spaces

Actualice el firewall o la configuración de seguridad para permitir el tráfico de red hacia y desde todos los FQDN siguientes y los servicios de infraestructura de Azure Dev Spaces.Update your firewall or security configuration to allow network traffic to and from the all of the below FQDNs and Azure Dev Spaces infrastructure services.

Reglas de red obligatoriasRequired network rules

Reglas de aplicación o FQDN obligatoriasRequired FQDN / application rules

Los clústeres de AKS que tienen habilitado Azure Dev Spaces necesitan las reglas de aplicación/FQDN siguientes:The following FQDN / application rules are required for AKS clusters that have the Azure Dev Spaces enabled:

Azure PolicyAzure Policy

Reglas de aplicación o FQDN obligatoriasRequired FQDN / application rules

Los clústeres de AKS que tienen habilitado Azure Policy necesitan las reglas de aplicación / FQDN siguientes.The following FQDN / application rules are required for AKS clusters that have the Azure Policy enabled.

Restricción del tráfico de salida mediante el firewall de AzureRestrict egress traffic using Azure firewall

Azure Firewall proporciona una etiqueta FQDN de Azure Kubernetes Service (AzureKubernetesService) para simplificar esta configuración.Azure Firewall provides an Azure Kubernetes Service (AzureKubernetesService) FQDN Tag to simplify this configuration.

A continuación se muestra un ejemplo de arquitectura de la implementación:Below is an example architecture of the deployment:

• La entrada publica se inserta en el flujo mediante filtros de firewallPublic Ingress is forced to flow through firewall filters
  • Los nodos de agente de AKS están aislados en una subred dedicada.AKS agent nodes are isolated in a dedicated subnet.
  • Azure Firewall se implementa en una subred propia.Azure Firewall is deployed in its own subnet.
  • Una regla de DNAT traduce la dirección IP pública del firewall en la dirección IP de front-end del equilibrador de carga.A DNAT rule translates the FW public IP into the LB frontend IP.
• Las solicitudes de salida parten de los nodos del agente hacia la dirección IP interna de Azure Firewall mediante una ruta definida por el usuarioOutbound requests start from agent nodes to the Azure Firewall internal IP using a user-defined route
  • Las solicitudes de los nodos de agente de AKS siguen una UDR que se ha colocado en la subred en la que se implementó el clúster de AKS.Requests from AKS agent nodes follow a UDR that has been placed on the subnet the AKS cluster was deployed into.
  • El firewall de Azure sale de la red virtual de un front-end con una IP pública.Azure Firewall egresses out of the virtual network from a public IP frontend
  • El acceso a la red pública de Internet u otros servicios de Azure fluye hacia y desde la dirección IP del servidor front-end del firewall.Access to the public internet or other Azure services flows to and from the firewall frontend IP address
  • Opcionalmente, el acceso al plano de control de AKS está protegido por intervalos IP autorizados del servidor de API, que incluye la dirección IP de front-end pública del firewall.Optionally, access to the AKS control plane is protected by API server Authorized IP ranges, which includes the firewall public frontend IP address.
• Tráfico internoInternal Traffic
  • Opcionalmente, en lugar o además de un equilibrador de carga público, puede usar un equilibrador de carga interno para el tráfico interno, que también se podría aislar en una subred propia.Optionally, instead or in addition to a Public Load Balancer you can use an Internal Load Balancer for internal traffic, which you could isolate on its own subnet as well.

En los pasos siguientes se usa la etiqueta de FQDN AzureKubernetesService de Azure Firewall para restringir el tráfico de salida desde el clúster de AKS y se proporciona un ejemplo de cómo configurar el tráfico de entrada público a través del firewall.The below steps make use of Azure Firewall's AzureKubernetesService FQDN tag to restrict the outbound traffic from the AKS cluster and provide an example how to configure public inbound traffic via the firewall.

Configuración mediante variables de entornoSet configuration via environment variables

Defina el conjunto de variables de entorno que se usarán en la creación de recursos.Define a set of environment variables to be used in resource creations.

PREFIX="aks-egress"
RG="${PREFIX}-rg"
LOC="eastus"
PLUGIN=azure
AKSNAME="${PREFIX}"
VNET_NAME="${PREFIX}-vnet"
AKSSUBNET_NAME="aks-subnet"
# DO NOT CHANGE FWSUBNET_NAME - This is currently a requirement for Azure Firewall.
FWSUBNET_NAME="AzureFirewallSubnet"
FWNAME="${PREFIX}-fw"
FWPUBLICIP_NAME="${PREFIX}-fwpublicip"
FWIPCONFIG_NAME="${PREFIX}-fwconfig"
FWROUTE_TABLE_NAME="${PREFIX}-fwrt"
FWROUTE_NAME="${PREFIX}-fwrn"
FWROUTE_NAME_INTERNET="${PREFIX}-fwinternet"

Creación de una red virtual con varias subredesCreate a virtual network with multiple subnets

Aprovisione una red virtual con dos subredes independientes, una para el clúster y otra para el firewall.Provision a virtual network with two separate subnets, one for the cluster, one for the firewall. Opcionalmente, también puede crear una para la entrada del servicio interno.Optionally you could also create one for internal service ingress.

Cree el grupo de recursos que contendrá todos los recursos.Create a resource group to hold all of the resources.

# Create Resource Group

az group create --name $RG --location $LOC

Cree una red virtual con dos subredes para hospedar el clúster de AKS y Azure Firewall.Create a virtual network with two subnets to host the AKS cluster and the Azure Firewall. Cada uno tendrá su propia subred.Each will have their own subnet. Comencemos con la red de AKS.Let's start with the AKS network.

# Dedicated virtual network with AKS subnet

az network vnet create \
    --resource-group $RG \
    --name $VNET_NAME \
    --location $LOC \
    --address-prefixes 10.42.0.0/16 \
    --subnet-name $AKSSUBNET_NAME \
    --subnet-prefix 10.42.1.0/24

# Dedicated subnet for Azure Firewall (Firewall name cannot be changed)

az network vnet subnet create \
    --resource-group $RG \
    --vnet-name $VNET_NAME \
    --name $FWSUBNET_NAME \
    --address-prefix 10.42.2.0/24

Creación y configuración de un firewall de Azure con una UDRCreate and set up an Azure Firewall with a UDR

Deben configurarse las reglas de entrada y salida del firewall de Azure.Azure Firewall inbound and outbound rules must be configured. El propósito principal del firewall es que las organizaciones puedan configurar reglas de tráfico de entrada y salida pormenorizadas hacia y desde el clúster de AKS.The main purpose of the firewall is to enable organizations to configure granular ingress and egress traffic rules into and out of the AKS Cluster.

Cree un recurso de SKU estándar con IP pública que se usará como dirección de front-end de Azure Firewall.Create a standard SKU public IP resource that will be used as the Azure Firewall frontend address.

az network public-ip create -g $RG -n $FWPUBLICIP_NAME -l $LOC --sku "Standard"

Registre la extensión de la CLI en versión preliminar para crear un firewall de Azure.Register the preview cli-extension to create an Azure Firewall.

# Install Azure Firewall preview CLI extension

az extension add --name azure-firewall

# Deploy Azure Firewall

az network firewall create -g $RG -n $FWNAME -l $LOC --enable-dns-proxy true

La dirección IP creada anteriormente puede asignarse ahora al front-end del firewall.The IP address created earlier can now be assigned to the firewall frontend.

# Configure Firewall IP Config

az network firewall ip-config create -g $RG -f $FWNAME -n $FWIPCONFIG_NAME --public-ip-address $FWPUBLICIP_NAME --vnet-name $VNET_NAME

Cuando el comando anterior se haya realizado correctamente, anote la dirección IP del servidor front-end del firewall para la configuración posterior.When the previous command has succeeded, save the firewall frontend IP address for configuration later.

# Capture Firewall IP Address for Later Use

FWPUBLIC_IP=$(az network public-ip show -g $RG -n $FWPUBLICIP_NAME --query "ipAddress" -o tsv)
FWPRIVATE_IP=$(az network firewall show -g $RG -n $FWNAME --query "ipConfigurations[0].privateIpAddress" -o tsv)

Creación de una UDR con un salto al firewall de AzureCreate a UDR with a hop to Azure Firewall

Azure enruta automáticamente el tráfico entre redes locales, las redes virtuales y las subredes de Azure.Azure automatically routes traffic between Azure subnets, virtual networks, and on-premises networks. Si desea cambiar algún enrutamiento predeterminado de Azure, debe crear una tabla de rutas.If you want to change any of Azure's default routing, you do so by creating a route table.

Cree una tabla de rutas vacía para asociarla a una subred determinada.Create an empty route table to be associated with a given subnet. La tabla de rutas definirá el próximo salto como el firewall de Azure creado anteriormente.The route table will define the next hop as the Azure Firewall created above. Cada subred puede tener cero o una ruta de tablas de ruta asociada.Each subnet can have zero or one route table associated to it.

# Create UDR and add a route for Azure Firewall

az network route-table create -g $RG -l $LOC --name $FWROUTE_TABLE_NAME
az network route-table route create -g $RG --name $FWROUTE_NAME --route-table-name $FWROUTE_TABLE_NAME --address-prefix 0.0.0.0/0 --next-hop-type VirtualAppliance --next-hop-ip-address $FWPRIVATE_IP --subscription $SUBID
az network route-table route create -g $RG --name $FWROUTE_NAME_INTERNET --route-table-name $FWROUTE_TABLE_NAME --address-prefix $FWPUBLIC_IP/32 --next-hop-type Internet

Consulte en la documentación sobre las tablas de rutas de red virtual cómo invalidar las rutas del sistema predeterminadas de Azure o agregar rutas adicionales a la tabla de rutas de una subred.See virtual network route table documentation about how you can override Azure's default system routes or add additional routes to a subnet's route table.

Adición de reglas de firewallAdding firewall rules

A continuación se muestran tres reglas de red que puede usar para configurar en el firewall; es posible que tenga que adaptarlas en función de la implementación.Below are three network rules you can use to configure on your firewall, you may need to adapt these rules based on your deployment. La primera regla permite el acceso al puerto 9000 a través de TCP.The first rule allows access to port 9000 via TCP. La segunda regla permite el acceso a los puertos 1194 y 123 a través de UDP (si va a implementar en Azure China 21Vianet, es posible que necesite más).The second rule allows access to port 1194 and 123 via UDP (if you're deploying to Azure China 21Vianet, you might require more). Las dos reglas solo permitirán el tráfico destinado al CIDR de la región de Azure que se use, en este caso, Este de EE. UU.Both these rules will only allow traffic destined to the Azure Region CIDR that we're using, in this case East US. Por último, se agrega una tercera regla de red para abrir el puerto 123 al FQDN ntp.ubuntu.com a través de UDP (la adición de un FQDN como una regla de red es una de las características específicas de Azure Firewall y tendrá que adaptarla cuando use opciones propias).Finally, we'll add a third network rule opening port 123 to ntp.ubuntu.com FQDN via UDP (adding an FQDN as a network rule is one of the specific features of Azure Firewall, and you'll need to adapt it when using your own options).

Después de establecer las reglas de red, también se agregará una regla de aplicación mediante AzureKubernetesService, que abarca todos los FQDN necesarios a los que se puede acceder a través del puerto TCP 443 y el puerto 80.After setting the network rules, we'll also add an application rule using the AzureKubernetesService that covers all needed FQDNs accessible through TCP port 443 and port 80.

# Add FW Network Rules

az network firewall network-rule create -g $RG -f $FWNAME --collection-name 'aksfwnr' -n 'apiudp' --protocols 'UDP' --source-addresses '*' --destination-addresses "AzureCloud.$LOC" --destination-ports 1194 --action allow --priority 100
az network firewall network-rule create -g $RG -f $FWNAME --collection-name 'aksfwnr' -n 'apitcp' --protocols 'TCP' --source-addresses '*' --destination-addresses "AzureCloud.$LOC" --destination-ports 9000
az network firewall network-rule create -g $RG -f $FWNAME --collection-name 'aksfwnr' -n 'time' --protocols 'UDP' --source-addresses '*' --destination-fqdns 'ntp.ubuntu.com' --destination-ports 123

# Add FW Application Rules

az network firewall application-rule create -g $RG -f $FWNAME --collection-name 'aksfwar' -n 'fqdn' --source-addresses '*' --protocols 'http=80' 'https=443' --fqdn-tags "AzureKubernetesService" --action allow --priority 100

Para más información acerca del servicio Azure Firewall, consulte la documentación de Azure Firewall.See Azure Firewall documentation to learn more about the Azure Firewall service.

Asociación de la tabla de rutas a AKSAssociate the route table to AKS

Para asociar el clúster al firewall, la subred dedicada del clúster debe hacer referencia a la tabla de rutas creada anteriormente.To associate the cluster with the firewall, the dedicated subnet for the cluster's subnet must reference the route table created above. Para crear la asociación, se puede emitir un comando a la red virtual que contiene el clúster y el firewall para actualizar la tabla de rutas de la subred del clúster.Association can be done by issuing a command to the virtual network holding both the cluster and firewall to update the route table of the cluster's subnet.

# Associate route table with next hop to Firewall to the AKS subnet

az network vnet subnet update -g $RG --vnet-name $VNET_NAME --name $AKSSUBNET_NAME --route-table $FWROUTE_TABLE_NAME

Implementación de AKS con el tipo de salida UDR a la red existenteDeploy AKS with outbound type of UDR to the existing network

Ahora, un clúster de AKS se puede implementar en una red virtual existente.Now an AKS cluster can be deployed into the existing virtual network. También se usará el tipo de salida userDefinedRouting; esta característica garantiza que se forzará el tráfico saliente a través del firewall y no existirán otras rutas de salida (de forma predeterminada, se podría usar el tipo de salida Load Balancer).We'll also use outbound type userDefinedRouting, this feature ensures any outbound traffic will be forced through the firewall and no other egress paths will exist (by default the Load Balancer outbound type could be used).

Creación de una entidad de servicio con acceso de aprovisionamiento dentro de la red virtual existenteCreate a service principal with access to provision inside the existing virtual network

AKS usa una entidad de servicio para crear recursos de clúster.A service principal is used by AKS to create cluster resources. La entidad de servicio que se pasa en el momento de la creación se usa para crear recursos de AKS subyacentes, como los recursos de almacenamiento, las direcciones IP y los equilibradores de carga que utiliza AKS (en su lugar también se puede usar una identidad administrada).The service principal that is passed at create time is used to create underlying AKS resources such as Storage resources, IPs, and Load Balancers used by AKS (you may also use a managed identity instead). Si no se le han concedido los permisos adecuados siguientes, no podrá aprovisionar el clúster de AKS.If not granted the appropriate permissions below, you won't be able to provision the AKS Cluster.

# Create SP and Assign Permission to Virtual Network

az ad sp create-for-rbac -n "${PREFIX}sp" --skip-assignment

Ahora, reemplace APPID y PASSWORD a continuación por el identificador de aplicación y la contraseña de la entidad de servicio, generados automáticamente por la salida del comando anterior.Now replace the APPID and PASSWORD below with the service principal appid and service principal password autogenerated by the previous command output. Se hará referencia al identificador de recurso de red virtual para conceder los permisos a la entidad de servicio para que AKS pueda implementar recursos en ella.We'll reference the VNET resource ID to grant the permissions to the service principal so AKS can deploy resources into it.

APPID="<SERVICE_PRINCIPAL_APPID_GOES_HERE>"
PASSWORD="<SERVICEPRINCIPAL_PASSWORD_GOES_HERE>"
VNETID=$(az network vnet show -g $RG --name $VNET_NAME --query id -o tsv)

# Assign SP Permission to VNET

az role assignment create --assignee $APPID --scope $VNETID --role "Network Contributor"

Aquí puede comprobar los permisos detallados necesarios.You can check the detailed permissions that are required here.

RTID=$(az network route-table show -g $RG -n $FWROUTE_TABLE_NAME --query id -o tsv)
az role assignment create --assignee $APPID --scope $RTID --role "Network Contributor"

Implementación de AKSDeploy AKS

Por último, el clúster de AKS se puede implementar en la subred existente que se ha dedicado al clúster.Finally, the AKS cluster can be deployed into the existing subnet we've dedicated for the cluster. La subred de destino en la que se va a realizar la implementación se define con la variable de entorno $SUBNETID.The target subnet to be deployed into is defined with the environment variable, $SUBNETID. No definimos la variable $SUBNETID en los pasos anteriores.We didn't define the $SUBNETID variable in the previous steps. Para establecer el valor del id. de la subred, puede usar el comando siguiente:To set the value for the subnet ID, you can use the following command:

SUBNETID=$(az network vnet subnet show -g $RG --vnet-name $VNET_NAME --name $AKSSUBNET_NAME --query id -o tsv)

Definirá el tipo de salida para usar el UDR que ya existe en la subred.You'll define the outbound type to use the UDR that already exists on the subnet. Esta configuración permitirá a AKS omitir la configuración y el aprovisionamiento de IP para el equilibrador de carga.This configuration will enable AKS to skip the setup and IP provisioning for the load balancer.

az aks create -g $RG -n $AKSNAME -l $LOC \
  --node-count 3 --generate-ssh-keys \
  --network-plugin $PLUGIN \
  --outbound-type userDefinedRouting \
  --service-cidr 10.41.0.0/16 \
  --dns-service-ip 10.41.0.10 \
  --docker-bridge-address 172.17.0.1/16 \
  --vnet-subnet-id $SUBNETID \
  --service-principal $APPID \
  --client-secret $PASSWORD \
  --api-server-authorized-ip-ranges $FWPUBLIC_IP

Habilitación del acceso de desarrollador al servidor de APIEnable developer access to the API server

Si en el paso anterior ha usado intervalos IP autorizados para el clúster, tendrá que agregar las direcciones IP de las herramientas de desarrollador a la lista de intervalos IP autorizados del clúster de AKS para poder acceder al servidor de API desde ahí.If you used authorized IP ranges for the cluster on the previous step, you must add your developer tooling IP addresses to the AKS cluster list of approved IP ranges in order to access the API server from there. Otra opción consiste en configurar una JumpBox con las herramientas necesarias en una subred independiente de la red virtual del firewall.Another option is to configure a jumpbox with the needed tooling inside a separate subnet in the Firewall's virtual network.

Agrege otra dirección IP a los intervalos autorizados con el siguiente comando:Add another IP address to the approved ranges with the following command

# Retrieve your IP address
CURRENT_IP=$(dig @resolver1.opendns.com ANY myip.opendns.com +short)

# Add to AKS approved list
az aks update -g $RG -n $AKSNAME --api-server-authorized-ip-ranges $CURRENT_IP/32

Use el comando [az aks get-credentials][az-aks-get-credentials] para configurar kubectl a fin de conectarse al clúster de Kubernetes recién creado.Use the [az aks get-credentials][az-aks-get-credentials] command to configure kubectl to connect to your newly created Kubernetes cluster.

az aks get-credentials -g $RG -n $AKSNAME

Implementación de un servicio públicoDeploy a public service

Ahora puede empezar a exponer servicios e implementar aplicaciones en este clúster.You can now start exposing services and deploying applications to this cluster. En este ejemplo, se expondrá un servicio público, pero también puede optar por exponer un servicio interno a través de un equilibrador de carga interno.In this example, we'll expose a public service, but you may also choose to expose an internal service via internal load balancer.

Para implementar aplicación de votación de Azure, copie el código YAML siguiente en un archivo llamado example.yaml.Deploy the Azure voting app application by copying the yaml below to a file named example.yaml.

# voting-storage-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: voting-storage
spec:
  replicas: 1
  selector:
    matchLabels:
      app: voting-storage
  template:
    metadata:
      labels:
        app: voting-storage
    spec:
      containers:
      - name: voting-storage
        image: mcr.microsoft.com/aks/samples/voting/storage:2.0
        args: ["--ignore-db-dir=lost+found"]
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 250m
            memory: 256Mi
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: voting-storage-secret
              key: MYSQL_ROOT_PASSWORD
        - name: MYSQL_USER
          valueFrom:
            secretKeyRef:
              name: voting-storage-secret
              key: MYSQL_USER
        - name: MYSQL_PASSWORD
          valueFrom:
            secretKeyRef:
              name: voting-storage-secret
              key: MYSQL_PASSWORD
        - name: MYSQL_DATABASE
          valueFrom:
            secretKeyRef:
              name: voting-storage-secret
              key: MYSQL_DATABASE
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim
---
# voting-storage-secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: voting-storage-secret
type: Opaque
data:
  MYSQL_USER: ZGJ1c2Vy
  MYSQL_PASSWORD: UGFzc3dvcmQxMg==
  MYSQL_DATABASE: YXp1cmV2b3Rl
  MYSQL_ROOT_PASSWORD: UGFzc3dvcmQxMg==
---
# voting-storage-pv-claim.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
---
# voting-storage-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: voting-storage
  labels: 
    app: voting-storage
spec:
  ports:
  - port: 3306
    name: mysql
  selector:
    app: voting-storage
---
# voting-app-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: voting-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: voting-app
  template:
    metadata:
      labels:
        app: voting-app
    spec:
      containers:
      - name: voting-app
        image: mcr.microsoft.com/aks/samples/voting/app:2.0
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
          name: http
        env:
        - name: MYSQL_HOST
          value: "voting-storage"
        - name: MYSQL_USER
          valueFrom:
            secretKeyRef:
              name: voting-storage-secret
              key: MYSQL_USER
        - name: MYSQL_PASSWORD
          valueFrom:
            secretKeyRef:
              name: voting-storage-secret
              key: MYSQL_PASSWORD
        - name: MYSQL_DATABASE
          valueFrom:
            secretKeyRef:
              name: voting-storage-secret
              key: MYSQL_DATABASE
        - name: ANALYTICS_HOST
          value: "voting-analytics"
---
# voting-app-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: voting-app
  labels: 
    app: voting-app
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
    name: http
  selector:
    app: voting-app
---
# voting-analytics-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: voting-analytics
spec:
  replicas: 1
  selector:
    matchLabels:
      app: voting-analytics
      version: "2.0"
  template:
    metadata:
      labels:
        app: voting-analytics
        version: "2.0"
    spec:
      containers:
      - name: voting-analytics
        image: mcr.microsoft.com/aks/samples/voting/analytics:2.0
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
          name: http
        env:
        - name: MYSQL_HOST
          value: "voting-storage"
        - name: MYSQL_USER
          valueFrom:
            secretKeyRef:
              name: voting-storage-secret
              key: MYSQL_USER
        - name: MYSQL_PASSWORD
          valueFrom:
            secretKeyRef:
              name: voting-storage-secret
              key: MYSQL_PASSWORD
        - name: MYSQL_DATABASE
          valueFrom:
            secretKeyRef:
              name: voting-storage-secret
              key: MYSQL_DATABASE
---
# voting-analytics-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: voting-analytics
  labels: 
    app: voting-analytics
spec:
  ports:
  - port: 8080
    name: http
  selector:
    app: voting-analytics

Para implementar el servicio, ejecute:Deploy the service by running:

kubectl apply -f example.yaml

Adición de una regla de DNAT al firewall de AzureAdd a DNAT rule to Azure Firewall

Para configurar la conectividad de entrada, se debe escribir una regla de DNAT en el firewall de Azure.To configure inbound connectivity, a DNAT rule must be written to the Azure Firewall. Para probar la conectividad con el clúster, se define una regla para la dirección IP pública de front-end del firewall que se va a enrutar a la dirección IP interna expuesta por el servicio interno.To test connectivity to your cluster, a rule is defined for the firewall frontend public IP address to route to the internal IP exposed by the internal service.

La dirección de destino se puede personalizar porque es el puerto del firewall al que se va a acceder.The destination address can be customized as it's the port on the firewall to be accessed. La dirección traducida debe ser la dirección IP del equilibrador de carga interno.The translated address must be the IP address of the internal load balancer. El puerto traducido debe ser el puerto expuesto para el servicio Kubernetes.The translated port must be the exposed port for your Kubernetes service.

Tendrá que especificar la dirección IP interna asignada al equilibrador de carga creado por el servicio Kubernetes.You'll need to specify the internal IP address assigned to the load balancer created by the Kubernetes service. Para recuperar la dirección, ejecute:Retrieve the address by running:

kubectl get services

La dirección IP necesaria se mostrará en la columna EXTERNAL-IP y será similar a la siguiente.The IP address needed will be listed in the EXTERNAL-IP column, similar to the following.

NAME               TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes         ClusterIP      10.41.0.1       <none>        443/TCP        10h
voting-analytics   ClusterIP      10.41.88.129    <none>        8080/TCP       9m
voting-app         LoadBalancer   10.41.185.82    20.39.18.6    80:32718/TCP   9m
voting-storage     ClusterIP      10.41.221.201   <none>        3306/TCP       9m

Para obtener la IP del servicio, ejecute lo siguiente:Get the service IP by running:

SERVICE_IP=$(kubectl get svc voting-app -o jsonpath='{.status.loadBalancer.ingress[*].ip}')

Para agregar la regla de NAT, ejecute lo siguiente:Add the NAT rule by running:

az network firewall nat-rule create --collection-name exampleset --destination-addresses $FWPUBLIC_IP --destination-ports 80 --firewall-name $FWNAME --name inboundrule --protocols Any --resource-group $RG --source-addresses '*' --translated-port 80 --action Dnat --priority 100 --translated-address $SERVICE_IP

Validar conectividadValidate connectivity

Vaya a la dirección IP de front-end del firewall de Azure en un explorador para validar la conectividad.Navigate to the Azure Firewall frontend IP address in a browser to validate connectivity.

Debería ver la aplicación de votación de AKS.You should see the AKS voting app. En este ejemplo, la dirección IP pública del firewall es 52.253.228.132.In this example, the Firewall public IP was 52.253.228.132.

Limpieza de recursosClean up resources

Para limpiar los recursos de Azure, elimine el grupo de recursos de AKS.To clean up Azure resources, delete the AKS resource group.

az group delete -g $RG

Pasos siguientesNext steps

En este artículo, ha aprendido qué puertos y direcciones se deben permitir si se quiere restringir el tráfico de salida para el clúster.In this article, you learned what ports and addresses to allow if you want to restrict egress traffic for the cluster. También ha visto cómo proteger el tráfico de salida mediante Azure Firewall.You also saw how to secure your outbound traffic using Azure Firewall.

Si es necesario, puede generalizar los pasos anteriores para reenviar el tráfico a la solución de salida preferida, si sigue la documentación del tipo de salida userDefinedRoute.If needed, you can generalize the steps above to forward the traffic to your preferred egress solution, following the Outbound Type userDefinedRoute documentation.

Si quiere restringir cómo se comunican los pods entre sí y con las restricciones de tráfico horizontal de derecha a izquierda en el clúster, vea Protección del tráfico entre pods mediante directivas de red en AKS.If you want to restrict how pods communicate between themselves and East-West traffic restrictions within cluster see Secure traffic between pods using network policies in AKS.