Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Pare-feu Azure for Containers vous permet de gérer la protection Pare-feu Azure des charges de travail Azure Kubernetes Service (AKS) au moyen de ressources personnalisées Kubernetes. Le contrôleur Pare-feu Azure traduit ces ressources en configuration et en stratégies pour Pare-feu Azure.
Dans cet article, vous créez un cluster AKS ou utilisez un cluster existant, installez le contrôleur, créez un pare-feu et configurez la protection pour le trafic sortant de certains pods.
Tip
Pour créer un nouveau cluster AKS et Pare-feu Azure avec un modèle Azure Resource Manager (ARM), utilisez le démarrage rapide du modèle ARM.
Important
Pare-feu Azure for Containers est actuellement en préversion publique. Consultez les Conditions d’utilisation supplémentaires pour les préversions Microsoft Azure pour les conditions légales qui s’appliquent aux fonctionnalités Azure en version bêta, en préversion ou qui ne sont pas encore publiées en disponibilité générale.
Comprendre le modèle de configuration
Le contrôleur utilise trois définitions de ressources personnalisées (CRD) :
| Resource | Purpose |
|---|---|
AzureFirewall |
Crée et gère un déploiement Pare-feu Azure. |
SecurityPolicy |
Définit les paramètres avancés du pare-feu, les règles réseau, les règles d’application ou une combinaison de ces paramètres. |
SecurityPolicyAttachment |
Fait référence aux politiques de sécurité, identifie le pare-feu et liste les sous-réseaux de la charge de travail AKS. Le contrôleur combine les politiques référencées dans une stratégie enfant Pare-feu Azure. |
Un SecurityPolicy ne s’applique pas au trafic tant qu’un SecurityPolicyAttachment n’y fait référence. Le trafic applicatif doit également traverser le pare-feu.
Le contrôleur supporte les sélecteurs de pod et d’espace de noms pour les collections de règles. Les paramètres avancés incluent la détection et la prévention des intrusions (IDPS), le DNS, l’intelligence des menaces et la traduction d’adresses réseau source (SNAT). La disponibilité des fonctionnalités dépend également du SKU du pare-feu et de sa configuration.
Prerequisites
- Un abonnement Azure et un accès à Pare-feu Azure pour conteneurs dans une région de prévisualisation prise en charge.
- Un cluster AKS qui utilise Azure CNI dans votre propre réseau virtuel, ou les autorisations pour en créer un. Azure CNI Overlay n'est pas pris en charge. Cette étape utilise un cluster et un réseau virtuel dans le même groupe de ressources.
- Un chemin de connectivité sortante pour le cluster pendant l’installation du contrôleur et la préparation du pare-feu. Avant de changer de routage, planifiez le type sortant du cluster et la connectivité sortante requise.
- Le trafic du pod doit atteindre le pare-feu avec l’IP du pod comme source, et non déguisé sous l’IP du nœud. Lors de la première association de stratégie, le contrôleur crée
kube-system/azure-ip-masq-agent-configpour désactiver le SNAT du pod. Si vous avez déjà une configuration personnaliséeip-masq-agent, assurez-vous qu’elle n’effectue pas de masquage de ce trafic de sortie. - Si vous utilisez un pare-feu existant ou fournissez votre propre politique de base, autorisez le trafic sortant AKS requis et le HTTPS sur le port 443 à
*.afc.azure.com. La politique de base créée par le contrôleur fournit déjà ces règles. - Permission d’administrer le cluster, d’installer des CRD et de créer les ressources réseau Azure dans ce guide.
- Permission de créer une identité gérée attribuée par l’utilisateur et d’attribuer son rôle requis. La création d’assignations de rôles nécessite un rôle approprié, tel qu’Administrateur du Role Based Access Control, dans le périmètre de l’affectation.
- L’Azure CLI, kubectl et Helm.
- Un environnement Bash, tel que Azure Cloud Shell en mode Bash.
Important
Azure CNI Overlay n'est pas pris en charge. Le cluster doit utiliser Azure CNI avec les IP pod du réseau virtuel (networkPluginest azure et networkPluginMode n'est pas défini).
Warning
Modifier la table de routage ou le type sortant d’un sous-réseau AKS peut interrompre la connectivité du cluster et des applications. Utilisez d’abord un environnement d’évaluation isolé. Enregistrez la configuration existante et préparez un plan de retour en arrière avant de modifier le trafic sortant.
L’aperçu prend en charge le cloud public Azure dans les régions suivantes. Utilisez une région disponible pour votre abonnement de préversion.
| Region | Valeur Azure CLI |
|---|---|
| EUAP USA Centre | centraluseuap |
| Est des États-Unis 2 EUAP | eastus2euap |
| Ouest du centre des États-Unis | westcentralus |
| East Asia | eastasia |
| UK South | uksouth |
| Central US | centralus |
Configurer l’environnement
Remplacez les deux valeurs d’espace réservé. Les autres noms sont des exemples ; changez-les selon les besoins, et pour un cluster existant, utilisez vos noms de ressources existants. Gardez la version contrôleur telle qu’indiquée. Utilisez Bash pour toutes les commandes de cet article.
# Required: replace these placeholders.
SUBSCRIPTION_ID='<subscription-id>'
LOCATION='<preview-region>'
# Example names: change as needed. For an existing cluster, use your existing resource names.
RESOURCE_GROUP='afc-rg'
VNET_NAME='afc-vnet'
VNET_CIDR='10.224.0.0/12'
AKS_SUBNET_NAME='aks-subnet'
AKS_SUBNET_CIDR='10.224.0.0/16'
AKS_NAME='aks-cluster'
VM_SIZE='Standard_DS3_v2' # must be available in your region
IDENTITY_RESOURCE_NAME='azure-firewall-identity'
HELM_NAMESPACE='firewall-namespace'
# Fixed value: the supported Azure Firewall Controller version for this preview. Use it as shown.
CONTROLLER_VERSION='20261109.1'
az login
az account set --subscription "$SUBSCRIPTION_ID"
Les exemples utilisent la version 20261109.1 du diagramme du contrôleur. Choisissez une taille de machine virtuelle disponible dans la région sélectionnée.
Enregistrez les fournisseurs de ressources :
az provider register --namespace Microsoft.ContainerService --wait
az provider register --namespace Microsoft.Network --wait
Préparez le cluster AKS
Choisissez l’option cluster existant ou nouveau cluster.
Utiliser un cluster existant
Vérifiez sa configuration réseau :
az aks show \
--resource-group "$RESOURCE_GROUP" \
--name "$AKS_NAME" \
--query 'networkProfile.{plugin:networkPlugin, mode:networkPluginMode}' -o json
Le plugin réseau doit être azure, et son mode doit être null, non overlay. Récupérer la région du cluster :
LOCATION=$(az aks show \
--resource-group "$RESOURCE_GROUP" \
--name "$AKS_NAME" \
--query location -o tsv)
Créer un cluster
Pour un nouvel environnement d’évaluation, créez le groupe de ressources, le réseau virtuel et le sous-réseau AKS :
az group create --name "$RESOURCE_GROUP" --location "$LOCATION"
az network vnet create \
--resource-group "$RESOURCE_GROUP" \
--name "$VNET_NAME" \
--location "$LOCATION" \
--address-prefixes "$VNET_CIDR"
az network vnet subnet create \
--resource-group "$RESOURCE_GROUP" \
--vnet-name "$VNET_NAME" \
--name "$AKS_SUBNET_NAME" \
--address-prefixes "$AKS_SUBNET_CIDR" \
--default-outbound-access false
AKS_SUBNET_ID=$(az network vnet subnet show \
--resource-group "$RESOURCE_GROUP" \
--vnet-name "$VNET_NAME" \
--name "$AKS_SUBNET_NAME" \
--query id -o tsv)
az aks create \
--resource-group "$RESOURCE_GROUP" \
--name "$AKS_NAME" \
--location "$LOCATION" \
--node-vm-size "$VM_SIZE" \
--vnet-subnet-id "$AKS_SUBNET_ID" \
--network-plugin azure \
--enable-oidc-issuer \
--enable-workload-identity \
--generate-ssh-keys
Ce chemin maintient la connectivité bootstrap du cluster disponible avant de créer la route du pare-feu. Il ne le sélectionne pas avant que cette route n’existe.
Enregistrer la configuration réseau
Pour l’un ou l’autre chemin, récupérez l’ID du sous-réseau AKS et enregistrez la table de routes, le type sortant et les serveurs DNS avant de les modifier :
AKS_SUBNET_ID=$(az network vnet subnet show \
--resource-group "$RESOURCE_GROUP" \
--vnet-name "$VNET_NAME" \
--name "$AKS_SUBNET_NAME" \
--query id -o tsv)
ORIGINAL_ROUTE_TABLE_ID=$(az network vnet subnet show \
--resource-group "$RESOURCE_GROUP" \
--vnet-name "$VNET_NAME" \
--name "$AKS_SUBNET_NAME" \
--query routeTable.id -o tsv)
echo "$ORIGINAL_ROUTE_TABLE_ID"
az aks show \
--resource-group "$RESOURCE_GROUP" \
--name "$AKS_NAME" \
--query networkProfile.outboundType -o tsv
az network vnet show \
--resource-group "$RESOURCE_GROUP" \
--name "$VNET_NAME" \
--query dhcpOptions.dnsServers -o json
Si une table de routes est déjà associée au sous-réseau, conservez ses routes requises. Ne remplacez pas une table de routage partagée par la table d’exemple sans en évaluer l’effet sur d’autres charges de travail.
Configurer une identité de charge de travail
Pour un cluster existant, activez l’émetteur OpenID Connect (OIDC) et l’identité de charge de travail. La commande new-cluster les active déjà. Attendez que la mise à jour soit terminée avant de récupérer l’URL de l’émetteur.
az aks update \
--resource-group "$RESOURCE_GROUP" \
--name "$AKS_NAME" \
--enable-oidc-issuer \
--enable-workload-identity
Créez une identité gérée dédiée attribuée par l’utilisateur pour le contrôleur :
az identity create \
--resource-group "$RESOURCE_GROUP" \
--name "$IDENTITY_RESOURCE_NAME"
IDENTITY_PRINCIPAL_ID=$(az identity show \
--resource-group "$RESOURCE_GROUP" \
--name "$IDENTITY_RESOURCE_NAME" \
--query principalId -o tsv)
IDENTITY_CLIENT_ID=$(az identity show \
--resource-group "$RESOURCE_GROUP" \
--name "$IDENTITY_RESOURCE_NAME" \
--query clientId -o tsv)
RESOURCE_GROUP_ID=$(az group show \
--name "$RESOURCE_GROUP" \
--query id -o tsv)
ROLE_ASSIGNMENT_ID=$(az role assignment create \
--assignee-object-id "$IDENTITY_PRINCIPAL_ID" \
--assignee-principal-type ServicePrincipal \
--role 'Network Contributor' \
--scope "$RESOURCE_GROUP_ID" \
--query id -o tsv)
Le contrôleur utilise cette identité pour gérer les pare-feux et les stratégies de pare-feu. Si ces ressources appartiennent à un groupe de ressources différent, accordez également à l’identité l’accès de contributeur réseau requis dans la périmètre de ce groupe de ressources. Laissez le temps pour que les changements d’identité et d’attribution de rôle se propagent avant de diagnostiquer une défaillance d’autorisation.
Créez l’identifiant fédéré :
AKS_OIDC_ISSUER=$(az aks show \
--resource-group "$RESOURCE_GROUP" \
--name "$AKS_NAME" \
--query oidcIssuerProfile.issuerUrl -o tsv)
az identity federated-credential create \
--resource-group "$RESOURCE_GROUP" \
--identity-name "$IDENTITY_RESOURCE_NAME" \
--name "$IDENTITY_RESOURCE_NAME" \
--issuer "$AKS_OIDC_ISSUER" \
--subject "system:serviceaccount:${HELM_NAMESPACE}:azurefirewall-controller-sa" \
--audience api://AzureADTokenExchange
L’espace de noms dans le sujet fédéré doit correspondre à celui que vous utilisez lors de l’installation du chart Helm. Le chart crée le compte de service azurefirewall-controller-sa.
Installer le contrôleur Pare-feu Azure
Connectez-vous au cluster avec kubectl et installez le contrôleur :
az aks get-credentials \
--resource-group "$RESOURCE_GROUP" \
--name "$AKS_NAME"
helm install azfw-controller \
oci://mcr.microsoft.com/firewall/charts/azurefirewall-controller \
--namespace "$HELM_NAMESPACE" \
--version "$CONTROLLER_VERSION" \
--set "azfwController.podIdentity.clientID=$IDENTITY_CLIENT_ID" \
--create-namespace
kubectl get pods --namespace "$HELM_NAMESPACE"
Vérifiez que les pods contrôleurs fonctionnent et que leurs conteneurs sont prêts avant de continuer.
Pour une release Helm existante, utilisez helm upgrade à la place de helm install:
helm upgrade azfw-controller \
oci://mcr.microsoft.com/firewall/charts/azurefirewall-controller \
--namespace "$HELM_NAMESPACE" \
--version "$CONTROLLER_VERSION" \
--set "azfwController.podIdentity.clientID=$IDENTITY_CLIENT_ID"
Préparer les ressources du pare-feu
La ressource pare-feu utilise un sous-réseau pare-feu, un sous-réseau de gestion, une ressource IP publique de plan de données et une ressource IP publique de gestion. Ignorez la création pour des ressources appropriées qui existent déjà.
Les noms des sous-réseaux doivent être AzureFirewallSubnet et AzureFirewallManagementSubnet. Choisissez des plages d’adresses au sein de votre réseau virtuel existant qui ne se chevauchent pas avec le sous-réseau AKS ni d’autres sous-réseaux. Les plages d’exemples suivantes nécessitent un espace d’adressage réseau virtuel qui les contient :
FW_SUBNET_NAME='AzureFirewallSubnet'
MGMT_SUBNET_NAME='AzureFirewallManagementSubnet'
FW_SUBNET_CIDR='10.225.0.0/26'
MGMT_SUBNET_CIDR='10.225.1.0/26'
FW_IP='fw-ip'
FW_MGMT_IP='fw-mgmt-ip'
az network vnet subnet create \
--resource-group "$RESOURCE_GROUP" \
--vnet-name "$VNET_NAME" \
--name "$FW_SUBNET_NAME" \
--address-prefixes "$FW_SUBNET_CIDR" \
--default-outbound-access false
az network vnet subnet create \
--resource-group "$RESOURCE_GROUP" \
--vnet-name "$VNET_NAME" \
--name "$MGMT_SUBNET_NAME" \
--address-prefixes "$MGMT_SUBNET_CIDR" \
--default-outbound-access false
az network public-ip create \
--resource-group "$RESOURCE_GROUP" --name "$FW_IP" \
--location "$LOCATION" --sku Standard \
--allocation-method Static --version IPv4
az network public-ip create \
--resource-group "$RESOURCE_GROUP" --name "$FW_MGMT_IP" \
--location "$LOCATION" --sku Standard \
--allocation-method Static --version IPv4
Récupérez les identifiants de ressources. La ressource personnalisée nécessite des identifiants de ressources Azure, et non des valeurs d’adresses IP publiques.
FW_SUBNET_ID=$(az network vnet subnet show \
--resource-group "$RESOURCE_GROUP" --vnet-name "$VNET_NAME" \
--name "$FW_SUBNET_NAME" --query id -o tsv)
MGMT_SUBNET_ID=$(az network vnet subnet show \
--resource-group "$RESOURCE_GROUP" --vnet-name "$VNET_NAME" \
--name "$MGMT_SUBNET_NAME" --query id -o tsv)
FW_IP_ID=$(az network public-ip show \
--resource-group "$RESOURCE_GROUP" --name "$FW_IP" --query id -o tsv)
FW_MGMT_IP_ID=$(az network public-ip show \
--resource-group "$RESOURCE_GROUP" --name "$FW_MGMT_IP" --query id -o tsv)
Créer le pare-feu
Créer firewall.yaml. Le heredoc non cité évalue les variables d’ID de ressource.
cat > firewall.yaml <<EOF
apiVersion: firewall.networking.azure.io/v1alpha1
kind: AzureFirewall
metadata:
name: example-firewall
namespace: default
spec:
data:
subnetId: ${FW_SUBNET_ID}
ipAddresses:
- ${FW_IP_ID}
management:
subnetId: ${MGMT_SUBNET_ID}
ipAddress: ${FW_MGMT_IP_ID}
EOF
kubectl apply -f firewall.yaml
kubectl wait --for=jsonpath='{.status.conditions[?(@.type=="Deployment")].reason}'=Ready \
azurefirewall/example-firewall --namespace default --timeout=30m
kubectl get azurefirewall example-firewall --namespace default -o yaml
Vous pouvez éventuellement ajouter spec.firewallPolicyReference avec l’ID de ressource d’une stratégie de pare-feu existante. Sans référence, le contrôleur crée une politique gérée.
La création peut prendre 10 à 15 minutes. Attendez que la Deploymentraison de la condition devienne Ready. L'attente uniquement du statut de la condition peut se terminer tant que le déploiement Azure est encore en cours. Inspectez les autres conditions retournées et corrigez les erreurs signalées avant de continuer.
Lisez l’adresse IP privée du pare-feu déployé à partir de son statut :
FW_PRIVATE_IP=$(kubectl get azurefirewall example-firewall --namespace default \
-o jsonpath='{.status.firewallResourceInfo.privateIPAddress}')
echo "$FW_PRIVATE_IP"
Pour utiliser un pare-feu existant à la place, ignorez la création de la AzureFirewall ressource et utilisez son ID de ressource Azure dans la pièce jointe décrite plus loin dans cet article. Le pare-feu existant doit utiliser une politique de pare-feu, et non des règles classiques.
Pour ce chemin, réglez FW_PRIVATE_IP sur l’adresse IP privée du pare-feu existant avant de configurer le routage :
FW_PRIVATE_IP='<existing-firewall-private-ip>'
Configurer une stratégie de sécurité
La politique suivante sélectionne les pods portant l’étiquette role: developer et autorise les requêtes HTTPS vers les sous-domaines Microsoft et Google utilisés dans le test. Cette politique ne remplace pas les règles d’infrastructure d’AKS.
Créez security-policy.yaml :
apiVersion: firewall.networking.azure.io/v1alpha1
kind: SecurityPolicy
metadata:
name: example-securitypolicy-rules
namespace: default
spec:
applicationRuleCollections:
- name: test-application-rules
refs:
- podSelector:
matchLabels:
role: developer
action: Allow
egress:
- name: allow-test-destinations
toPortProtocol:
- protocolType: HTTPS
port: 443
to:
- fqdn:
- "*.microsoft.com"
- "*.google.com"
Appliquez la politique :
kubectl apply -f security-policy.yaml
Options de règles réseau et d’application
Chaque collection permet refs de sélectionner des pods, des espaces de noms, ou les deux, et un action de Allow ou Deny.
| Collection | Options de configuration |
|---|---|
networkRuleCollections |
TCP, UDP, ICMP ou ANY ; ports ; adresses IP ; groupes IP ; balises de service ; et FQDN. |
applicationRuleCollections |
HTTP, HTTPS ou MSSQL ; ports ; FQDN ; balises FQDN ; URLs ; et catégories web. |
Par exemple, le fragment suivant spec active le proxy DNS et ajoute une collection de règles réseau qui sélectionne les pods de développeur et autorise le trafic du port TCP 443 vers google.com. N’ajoutez pas cet exemple facultatif à la stratégie de test « application uniquement » sans réévaluer les résultats de test attendus.
dns:
dnsProxy: Enabled
networkRuleCollections:
- name: example-network-rules
refs:
- podSelector:
matchLabels:
role: developer
action: Allow
egress:
- name: allow-google
toPortProtocol:
- protocolType: TCP
port: 443
to:
- fqdn:
- google.com
Une destination FQDN dans une règle réseau nécessite dns.dnsProxy: Enabled. Les pods doivent également résoudre le FQDN via le pare-feu afin que le DNS du pod et le DNS du pare-feu ne résolvent pas des adresses IP différentes.
Pour cet exemple optionnel de règle réseau, attachez d’abord la stratégie et attendez qu’elle soit prête comme décrit dans Joindre la politique. Ensuite, configurez le DNS du pod pour utiliser le pare-feu. Une option consiste à définir le serveur DNS du réseau virtuel sur l’IP privée du pare-feu :
az network vnet update \
--resource-group "$RESOURCE_GROUP" \
--name "$VNET_NAME" \
--dns-servers "$FW_PRIVATE_IP"
Modifier le DNS du réseau virtuel affecte d’autres charges de travail dans ce réseau. Enregistrez d’abord la configuration DNS originale, puis redémarrez les nœuds AKS via votre procédure de maintenance afin qu’ils détectent la modification. Sinon, configurez CoreDNS pour transférer vers le pare-feu. Les règles d’application HTTP et HTTPS ne nécessitent pas ce chemin de résolution DNS.
Les règles d’application peuvent utiliser tlsInspection: Enabled. L’inspection TLS nécessite également le SKU du pare-feu approprié, la configuration du certificat et la confiance client. Voir certificats Pare-feu Azure Premium.
Acheminer le trafic AKS via le pare-feu
Important
Configurez le routage avant d’attacher une stratégie. Attachment désactive le SNAT du pod afin que le pare-feu voie les IP source du pod. Sans la route du pare-feu, les pods peuvent perdre la connectivité sortante dès que l’attachement entre en vigueur.
Lorsque le contrôleur crée une politique de base, il autorise déjà le port TCP 443 vers le AzureKubernetesService tag de service, le port HTTPS 443 vers le AzureKubernetesService tag FQDN, et le port HTTPS 443 vers *.afc.azure.com.
Si vous utilisez un pare-feu existant ou fournissez firewallPolicyReference, configurez les règles réseau AKS et FQDN requises équivalentes ainsi que le port HTTPS 443 vers *.afc.azure.com dans votre politique de base avant de modifier le routage. Le contrôleur ne modifie pas une politique de base fournie. Maintenez la connectivité pour les services de cluster, le DNS et la récupération des images. Ne modifiez pas directement la politique enfant gérée par le contrôleur.
Pour un sous-réseau d’évaluation dédié sans tableau de routage existant, créez la table suivante. Utilisez la valeur FW_PRIVATE_IP récupérée dans l’état du pare-feu, ou l’adresse IP privée de votre pare-feu existant.
FW_ROUTE_TABLE_NAME='fw-rt'
FW_ROUTE_NAME='to-firewall'
az network route-table create \
--resource-group "$RESOURCE_GROUP" \
--location "$LOCATION" \
--name "$FW_ROUTE_TABLE_NAME"
az network route-table route create \
--resource-group "$RESOURCE_GROUP" \
--route-table-name "$FW_ROUTE_TABLE_NAME" \
--name "$FW_ROUTE_NAME" \
--address-prefix 0.0.0.0/0 \
--next-hop-type VirtualAppliance \
--next-hop-ip-address "$FW_PRIVATE_IP"
az network vnet subnet update \
--resource-group "$RESOURCE_GROUP" \
--vnet-name "$VNET_NAME" \
--name "$AKS_SUBNET_NAME" \
--route-table "$FW_ROUTE_TABLE_NAME"
kubectl get nodes
Si une table de routage existe déjà, ajoutez la route par défaut du pare-feu à cette table au lieu de la remplacer. Préservez ses autres routes obligatoires.
Associer une table de routage ne modifie pas le sous-réseau AKS outboundType. Si votre conception nécessite une migration vers userDefinedRouting, suivez la procédure de migration prise en charge dans Customize cluster egress with outbound types. Terminez la configuration de sortie et vérifiez la connectivité du cluster avant de continuer.
Joindre la police d’assurance
Une fois le routage en place, créez attachment.yaml. Cet exemple fait référence à la stratégie et au pare-feu géré créés dans ce guide.
cat > attachment.yaml <<EOF
apiVersion: firewall.networking.azure.io/v1alpha1
kind: SecurityPolicyAttachment
metadata:
name: example-attachment
namespace: default
spec:
securityPolicyRefs:
- name: example-securitypolicy-rules
namespace: default
firewallRef:
name: example-firewall
namespace: default
aksWorkloadSubnets:
- ${AKS_SUBNET_ID}
EOF
kubectl apply -f attachment.yaml
kubectl wait --for=jsonpath='{.status.conditions[?(@.type=="Deployment")].reason}'=Ready \
securitypolicyattachment/example-attachment --namespace default --timeout=30m
kubectl get securitypolicyattachment example-attachment --namespace default -o yaml
Pour un pare-feu existant, remplacez le nom et l’espace de noms firewallRef par un id:
firewallRef:
id: <firewall-resource-id>
| Champ | Description |
|---|---|
securityPolicyRefs |
Politiques à combiner, identifiées par nom et espace de noms. |
firewallRef |
Required. Soit le nom et l'espace de noms Kubernetes du pare-feu géré, soit l'ID de ressource Azure d'un pare-feu existant. |
aksWorkloadSubnets |
Required. IDs de ressources Azure des sous-réseaux AKS protégés par le pare-feu. |
Attendez que la raison de Deployment l’attachement devienne Ready, pas seulement que son statut passe à true. Vérifiez également les conditions de résolution de référence et d’acceptation.
Mises à jour de la politique, ordre de priorité et suppression
IDPS, renseignement sur les menaces, DNS et SNAT sont des réglages à l’échelle des politiques. Si plusieurs politiques définissent le même paramètre, la première politique dans securityPolicyRefs l’emporte.
Si Azure rejette une version de politique, le contrôleur conserve sa dernière version connue comme bonne ou omet cette politique s’il n’a pas de bonne version. Il ne réessaie pas la version rejetée simplement parce que l’erreur sous-jacente disparaît. Corrigez le problème et changez le spec de la politique avant de les réappliquer.
Supprimer une stratégie de securityPolicyRefs avant de supprimer la ressource de stratégie. Sinon, la suppression peut se bloquer. Pour recréer une stratégie rejetée, détachez-la d’abord, supprimez-la, puis recréez-la et rattachez-la.
Tester le trafic des applications
Créez un pod de test avec l’étiquette sélectionnée par la stratégie :
kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
name: developer-pod
namespace: default
labels:
role: developer
spec:
containers:
- name: developer
image: mcr.microsoft.com/azure-cli:latest
command: ["sleep", "infinity"]
EOF
kubectl wait --for=condition=Ready pod/developer-pod \
--namespace default --timeout=5m
Après que le pod ait fonctionné, ouvrez une coque :
kubectl exec --namespace default -it developer-pod -- /bin/bash
Depuis le shell du pod, testez les destinations autorisées :
curl --connect-timeout 10 --max-time 30 https://www.google.com
curl --connect-timeout 10 --max-time 30 https://www.microsoft.com
Testez ensuite une destination non autorisée par la politique d’exemple :
curl --connect-timeout 10 --max-time 30 https://www.bing.com
echo "$?"
Dans la configuration de politique isolée prévue, les deux premières requêtes sont autorisées et la requête Bing est refusée. Pour une requête HTTPS refusée, le pare-feu réinitialise la connexion TLS et curl renvoie le code 35de sortie. Corrélér les résultats avec les journaux Pare-feu Azure et la politique déployée. Un délai d’attente ou une erreur TLS à elle seule ne prouve pas quelle règle du pare-feu a traité la requête.
Les modifications des règles et des libellés peuvent prendre quelques minutes pour parvenir au pare-feu après que la condition de l’attachement Deployment a pour raison Ready. Si un résultat n’est pas celui auquel vous vous attendez, laissez le temps à la convergence et réessayez avant de commencer le dépannage.
Quittez la coque du pod lorsque vous avez terminé :
exit
Vérifier qu’un nouveau pod correspond à la politique
Après que la politique existante converge, créez un autre pod portant la même étiquette :
kubectl run developer-pod-2 --namespace default --labels=role=developer \
--image=mcr.microsoft.com/azure-cli:latest --command -- sleep infinity
kubectl wait --for=condition=Ready pod/developer-pod-2 \
--namespace default --timeout=5m
kubectl exec developer-pod-2 --namespace default -- \
curl -sS -o /dev/null -w '%{http_code}\n' --max-time 30 https://www.microsoft.com
Le nouveau pod étiqueté devient autorisé en quelques secondes sans déploiement Azure Resource Manager. Cette mise à jour rapide du pod est distincte du délai de convergence des modifications de stratégie ou d’étiquette.
Configurer les paramètres avancés de stratégie
Un SecurityPolicy peut également définir les paramètres suivants. Une politique distincte doit être référencée par la liaison avant qu’elle ne prenne effet. Évaluez chaque fonctionnalité individuellement plutôt que d’appliquer chaque exemple à l’environnement de test.
| Setting | Options |
|---|---|
| Système de Détection et de Prévention d'Intrusion (IDPS) |
Disabled, AlertOnly, ou AlertAndDeny ; exceptions de signature ; et plages privées. |
| Renseignement sur les menaces |
Disabled, AlertOnly, ou AlertAndDeny; CIDR et FQDN autorisés. |
| DNS |
dnsProxy réglé sur Enabled ou Disabled, avec customNameServers en option. Sans serveurs personnalisés, la configuration utilise Azure DNS. |
| SNAT |
Always, Never, ou Exclude. Spécifiez exclusions uniquement avec Exclude. |
Système de Détection et de Prévention d'Intrusion (IDPS)
Le fragment suivant spec montre la configuration IDPS. Un ruleID doit être un nombre, pas une chaîne entre guillemets. Remplacez l’ID 2000015 de signature d’exemple par l’ID numérique d’une signature que vous souhaitez remplacer.
idps:
mode: AlertAndDeny
ruleOverrides:
- ruleID: 2000015
mode: AlertOnly
privateIPRanges:
cidrs:
- 10.0.0.0/8
- 192.168.0.0/16
Ne pas configurer bypassList sur la politique enfant gérée par le contrôleur. Azure rejette ce paramètre. Si vous avez besoin d’un contournement IDPS spécifique, configurez une politique de base appropriée dont vous êtes propriétaire.
Renseignement sur les menaces
Le fragment suivant spec montre comment autoriser des CIDR et FQDN spécifiques tout en utilisant le renseignement sur les menaces :
threatIntelligence:
mode: AlertAndDeny
allow-list:
cidrs:
- 203.0.113.0/24
- 198.51.100.0/24
fqdns:
- example.com
- example.org
DNS
Le fragment suivant spec active le proxy DNS. Configurez customNameServers avec vos propres adresses du résolveur DNS lorsque votre conception DNS les exige.
dns:
dnsProxy: Enabled
customNameServers:
- <dns-server-ip-1>
- <dns-server-ip-2>
SNAT
Le fragment suivant spec exclut les plages privées listées de SNAT :
snat:
action: Exclude
exclusions:
autoLearnPrivateRanges: Enabled
privateRanges:
- 10.0.0.0/8
- 192.168.0.0/16
Dépannez la configuration et le déploiement
Commencez par les pods de contrôleur, l’image et les logs :
kubectl get pods --namespace "$HELM_NAMESPACE"
kubectl get pods --namespace "$HELM_NAMESPACE" \
-l app=azurefirewall-controller \
-o jsonpath='{.items[0].spec.containers[0].image}'
kubectl logs --namespace "$HELM_NAMESPACE" \
-l app=azurefirewall-controller
L’image du contrôleur utilise le chemin mcr.microsoft.com/firewall/images/azurefirewall-controller avec la balise de version sélectionnée.
Inspectez les ressources et leur état :
kubectl get azurefirewall -A -o yaml
kubectl get securitypolicy -A -o yaml
kubectl get securitypolicyattachment -A -o yaml
| Problème | Contrôles |
|---|---|
| Échec d’authentification ou HTTP 401 | Vérifiez la configuration de l’émetteur OIDC, du sujet fédéré, de l’espace de noms et de l’identité de charge de travail. |
| Échec d’autorisation ou HTTP 403 | Vérifiez les attributions de rôle de l’identité du contrôleur ainsi que leur périmètre. |
| Erreur de validation de la ressource | Inspectez les conditions de statut de la ressource. Vérifiez que les valeurs IP publiques et les valeurs de sous-réseau sont des identifiants de ressources Azure valides. |
| Échec du déploiement Azure | Vérifiez l’erreur signalée et le journal d’activité Azure. Vérifiez que les ressources référencées existent et se trouvent dans l’emplacement requis. |
| Résultat inattendu du trafic | Vérifiez le routage, le déploiement des attachements, les sélecteurs et les autres règles de pare-feu applicables. |
| La règle réseau FQDN est rejetée | Activez dns.dnsProxy: Enabled dans la politique. |
| La règle réseau FQDN ne s’applique pas | Assurez-vous que les pods résolvent la destination via le pare-feu, en utilisant le DNS réseau virtuel ou le transfert CoreDNS. |
FirewallPolicyChildPolicyIntrusionDetectionBypassTrafficSettingConfigurationError |
Supprimer bypassList de la politique gérée par le contrôleur. |
La politique demeure Programmed=False |
Corrigez la configuration rejetée et modifiez le/la spec de la stratégie avant de la réappliquer. Une version rejetée n’est pas automatiquement réessayée. Sinon, détachez-le, supprimez-le et recréez-le. |
Supprimer un SecurityPolicy blocage |
Supprimez-le du securityPolicyRefs de la pièce jointe avant de le supprimer. |
| Les pods perdent leur connexion internet après la connexion | Vérifiez l’itinéraire du 0.0.0.0/0 sous-réseau AKS vers le pare-feu ainsi que les règles AKS et *.afc.azure.com de sortie requises. |
| Les pods étiquetés sont rejetés de manière inattendue | Laissez le temps de convergence et réessayez. Vérifiez la région d’aperçu, le CNI Azure non-superposé, et kube-system/azure-ip-masq-agent-config. Vérifiez que le pare-feu détecte l’IP du pod plutôt que l’IP du nœud. |
Pour l’identité de la charge de travail, inspectez l’environnement du compte de service et du pod contrôleur :
kubectl get serviceaccount azurefirewall-controller-sa \
--namespace "$HELM_NAMESPACE" -o yaml
kubectl get pods --namespace "$HELM_NAMESPACE" \
-l app=azurefirewall-controller \
-o jsonpath='{.items[0].spec.containers[0].env}'
az role assignment list \
--assignee "$IDENTITY_CLIENT_ID" \
--scope "$RESOURCE_GROUP_ID"
Vérifiez l’annotation azure.workload.identity/client-id du compte de service et l’étiquette du azure.workload.identity/use pod. L’ID client d’identité est fourni via AZURE_CLIENT_ID. La configuration de l’identité de la charge de travail fournit également le tenant, le fichier de jeton fédéré et l’hôte d’autorité.
Limitations de la version préliminaire
- Chaque cluster AKS ne supporte qu’un
SecurityPolicyAttachmentseul et un Pare-feu Azure. Chaque pare-feu ne prend en charge qu’un seul cluster. - L’aperçu inspecte uniquement la sortie des pods et supporte uniquement IPv4.
- Azure CNI Overlay n'est pas pris en charge.
- Les pods hôte-réseau utilisent l’IP du nœud et ne peuvent pas être sélectionnés individuellement.
- Les déploiements de pare-feu géré et de stratégie de pare-feu utilisent par défaut le SKU Premium.
- Vous pouvez utiliser un pare-feu et une politique SKU Standard existants pour les règles basées sur les étiquettes, mais les fonctionnalités IDPS réservées à Premium, l’inspection TLS et le filtrage d’URL ne sont pas disponibles.
- Une politique de base ne doit pas déjà hériter d’une autre politique de base.
- Vous pouvez modifier la politique parente via le portail Azure. Le contrôleur n’annule pas ces modifications apportées à la stratégie parente.
- Ne modifiez pas la politique enfant gérée par le contrôleur via le portail Azure. Kubernetes en est la source de vérité.
- Un pare-feu existant doit utiliser une politique de pare-feu. Les règles classiques ne sont pas prises en charge pour cette intégration.
- Les CRD utilisent
v1alpha1et peuvent changer avant la disponibilité générale. - L’aperçu supporte uniquement le cloud public Azure, dans les régions d’aperçu listées.
Nettoyer les ressources
Gardez le contrôleur en marche pendant que vous supprimez les ressources qu’il gère. Si vous désinstallez d’abord le contrôleur, la réconciliation et la suppression des ressources pourraient ne pas être terminées.
Quittez le shell du pod de test et supprimez les pods de test.
kubectl delete pod developer-pod developer-pod-2 --namespace defaultSupprimez la pièce jointe et attendez que la suppression se termine. Ensuite, attendez environ 90 secondes pour que le pod SNAT soit rétabli.
kubectl delete securitypolicyattachment example-attachment --namespace default kubectl wait --for=delete securitypolicyattachment/example-attachment \ --namespace default --timeout=30m sleep 90Rétablissez le routage précédent du sous-réseau et la configuration sortante requise du cluster selon votre plan de rollback. Si le sous-réseau n’avait à l’origine aucune table de routage, supprimez l’association de la table d’évaluation. Sinon, restaurez sa table d’origine.
if [ -n "$ORIGINAL_ROUTE_TABLE_ID" ]; then az network vnet subnet update \ --resource-group "$RESOURCE_GROUP" --vnet-name "$VNET_NAME" \ --name "$AKS_SUBNET_NAME" --route-table "$ORIGINAL_ROUTE_TABLE_ID" else az network vnet subnet update \ --resource-group "$RESOURCE_GROUP" --vnet-name "$VNET_NAME" \ --name "$AKS_SUBNET_NAME" --remove routeTable fiSi vous avez modifié le DNS réseau virtuel ou le CoreDNS pour l’exemple optionnel de la règle réseau, rétablissez également les paramètres d’origine. Vérifiez la connectivité du cluster. Ne laissez pas un itinéraire pointant vers un pare-feu que vous êtes sur le point de supprimer.
Supprimez la politique d’évaluation après avoir retiré sa pièce jointe.
kubectl delete securitypolicy example-securitypolicy-rules --namespace defaultSi vous avez créé le pare-feu géré dans cette procédure, supprimez sa ressource personnalisée tant que le contrôleur est encore en cours d’exécution :
kubectl delete azurefirewall example-firewall --namespace default kubectl wait --for=delete azurefirewall/example-firewall \ --namespace default --timeout=40mLa suppression peut prendre 20 à 30 minutes. Vérifiez la suppression du déploiement Azure associé. Ne supprimez pas un pare-feu existant que vous avez indiqué par son ID de ressource.
Une fois la suppression des ressources gérées terminée, désinstallez le contrôleur.
helm uninstall azfw-controller --namespace "$HELM_NAMESPACE"Supprimez l’espace de noms du contrôleur uniquement si vous l’avez créé exclusivement pour cette procédure pas à pas et qu’il ne contient aucune ressource dont vous avez besoin.
Les commandes précédentes ne supriment pas le cluster AKS, le réseau virtuel, les sous-réseaux, les ressources IP publiques, la table de routes, l’identité ou l’attribution de rôles. Supprimez uniquement les ressources que vous avez créées exclusivement pour cette évaluation après avoir vérifié qu’aucune autre charge de travail ne les utilise. En particulier, conservez les ressources réseau préexistantes et restaurez leur configuration d’origine.