Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Firewall di Azure for Containers ti permette di gestire la protezione Firewall di Azure per i carichi di lavoro di Servizio Azure Kubernetes (AKS) tramite risorse personalizzate Kubernetes. Il Firewall di Azure Controller traduce queste risorse in configurazione e policy di Firewall di Azure.
In questo articolo, puoi creare un cluster AKS oppure utilizzare un cluster esistente, installare il controller, creare un firewall e configurare la protezione per il traffico in uscita dei pod selezionati.
Tip
Per creare un nuovo cluster AKS e Firewall di Azure con un modello Azure Resource Manager (ARM), utilizza il quickstart del modello ARM.
Importante
Firewall di Azure for Containers è attualmente in anteprima pubblica. Vedi le Condizioni supplementari d'uso per le anteprime di Microsoft Azure per conoscere le condizioni legali applicabili alle funzionalità di Azure che sono in beta, in anteprima o non ancora rilasciate nella disponibilità generale.
Comprendere il modello di configurazione
Il controller utilizza tre definizioni personalizzate di risorse (CRD):
| Risorsa | Purpose |
|---|---|
AzureFirewall |
Crea e gestisce una distribuzione Firewall di Azure. |
SecurityPolicy |
Definisce impostazioni avanzate del firewall, regole di rete, regole applicative o una combinazione di queste impostazioni. |
SecurityPolicyAttachment |
Fa riferimento alle policy di sicurezza, identifica il firewall e elenca le sottoreti del carico di lavoro AKS. Il controller combina i criteri a cui si fa riferimento in un criterio figlio di Firewall di Azure. |
A SecurityPolicy non si applica al traffico finché un SecurityPolicyAttachment non lo richiama. Il traffico applicativo deve anche attraversare il firewall.
Il controller supporta selettori di pod e namespace per le raccolte di regole. Le impostazioni avanzate includono rilevamento e prevenzione delle intrusioni (IDPS), DNS, intelligence delle minacce e traduzione degli indirizzi di rete sorgente (SNAT). La disponibilità delle funzionalità dipende anche dallo SKU del firewall e dalla sua configurazione.
Prerequisites
- Un abbonamento Azure e accesso a Firewall di Azure for Containers in una regione di anteprima supportata.
- Un cluster AKS che utilizza Azure CNI nella propria rete virtuale, oppure autorizzazioni per crearne una. Azure CNI Overlay non è supportato. Questa guida utilizza un cluster e una rete virtuale nello stesso gruppo di risorse.
- Percorso di connettività in uscita per il cluster durante l'installazione del controller e la preparazione del firewall. Prima di cambiare il routing, pianifica il tipo di uscita del cluster e la connettività in uscita richiesta.
- Il traffico del pod deve raggiungere il firewall con l'IP del pod come sorgente, non mascherato con l'IP del nodo. Alla prima associazione della policy, il controller crea
kube-system/azure-ip-masq-agent-configper disattivare il pod SNAT. Se hai già una configurazione personalizzataip-masq-agent, assicurati che non mascheri questo traffico di uscita. - Se utilizzi un firewall esistente o fornisci la tua policy di base, consenti il traffico in uscita AKS richiesto e il traffico HTTPS sulla porta 443 verso
*.afc.azure.com. La policy base creata dal controller fornisce già queste regole. - Autorizzazione per amministrare il cluster, installare i CRD e creare le risorse di rete Azure in questa guida.
- Permesso per creare un'identità gestita assegnata dall'utente e assegnarne il ruolo richiesto. La creazione di assegnazioni di ruolo richiede un ruolo appropriato, come Role Based Controllo di accesso Administrator, all'interno dell'ambito dell'assegnazione.
- L'interfaccia della riga di comando di Azure, kubectl e Helm.
- Un ambiente Bash, come Azure Cloud Shell in modalità Bash.
Importante
Azure CNI Overlay non è supportato. Il cluster deve usare Azure CNI con IP pod provenienti dalla rete virtuale (networkPluginè azure e networkPluginMode non è impostato).
Avvertimento
La modifica della tabella di routing di una subnet AKS o del tipo di uscita del cluster può interrompere la connettività del cluster e delle applicazioni. Utilizza innanzitutto un ambiente di valutazione isolato. Registra la configurazione esistente e prepara un piano di rollback prima di modificare il traffico in uscita.
L'anteprima supporta il cloud pubblico Azure nelle seguenti regioni. Usa una regione abilitata per il tuo abbonamento di anteprima.
| Region | Valore interfaccia della riga di comando di Azure |
|---|---|
| Stati Uniti centrali (EUAP) | centraluseuap |
| Stati Uniti orientali 2 EUAP | eastus2euap |
| Stati Uniti centro-occidentali | westcentralus |
| East Asia | eastasia |
| UK South | uksouth |
| Central US | centralus |
Configurare l'ambiente
Sostituisci i due valori segnaposto. Gli altri nomi sono esempi; modificali secondo necessità e, per un cluster esistente, usa i nomi delle risorse esistenti. Mantieni la versione del controller come mostrata. Usa Bash per tutti i comandi in questo articolo.
# 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"
Gli esempi utilizzano la versione 20261109.1del diagramma del controller . Scegli una dimensione di macchina virtuale disponibile nella regione selezionata.
Registra i fornitori di risorse:
az provider register --namespace Microsoft.ContainerService --wait
az provider register --namespace Microsoft.Network --wait
Prepara il cluster AKS
Scegli il percorso existing-cluster o new-cluster.
Usare un cluster esistente
Controlla la configurazione della rete:
az aks show \
--resource-group "$RESOURCE_GROUP" \
--name "$AKS_NAME" \
--query 'networkProfile.{plugin:networkPlugin, mode:networkPluginMode}' -o json
Il plugin di rete deve essere azure, e la sua modalità deve essere null, non overlay. Recupera la regione del cluster:
LOCATION=$(az aks show \
--resource-group "$RESOURCE_GROUP" \
--name "$AKS_NAME" \
--query location -o tsv)
Creare un nuovo cluster
Per un nuovo ambiente di valutazione, crea il gruppo di risorse, la rete virtuale e la subnet 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
Questo percorso mantiene disponibile la connettività bootstrap del cluster prima di creare la rotta firewall. Non utilizza userDefinedRouting finché quel percorso non esiste.
Registra la configurazione della rete
Per ciascuno dei percorsi, recupera l'ID della subrete AKS e registra la tabella di percorso, il tipo di uscita e i server DNS prima di modificarli:
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
Se una tabella di routing è già associata alla sottonet, conserva le sue rotte richieste. Non sostituire una tabella di routing condivisa con la tabella di esempio senza valutare l'effetto sugli altri carichi di lavoro.
Configurare l'identità del carico di lavoro
Per un cluster esistente, abilita l'emittente OpenID Connect (OIDC) e l'identità del carico di lavoro. Il comando new-cluster li abilita già. Attendi che l'aggiornamento si completi prima di recuperare l'URL dell'emittente.
az aks update \
--resource-group "$RESOURCE_GROUP" \
--name "$AKS_NAME" \
--enable-oidc-issuer \
--enable-workload-identity
Crea un'identità gestita dedicata assegnata dall'utente per il controller:
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)
Il controller utilizza questa identità per gestire firewall e Firewall Policy. Se queste risorse appartengono a un gruppo di risorse diverso, conceda all'identità l'accesso richiesto al Contributore di rete anche nell'ambito di quel gruppo di risorse. Attendere il tempo necessario affinché le modifiche all'identità e all'assegnazione di ruolo si propaghino prima di diagnosticare un errore di autorizzazione.
Crea l'accreditazione federata:
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
Il namespace nel soggetto federato deve corrispondere allo namespace che usi durante l'installazione del chart Helm. Il chart crea l'account di servizio azurefirewall-controller-sa.
Installa il Firewall di Azure Controller
Collega kubectl al cluster e installa il controller:
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"
Verifica che i pod del controller siano in funzione e che i loro contenitori siano pronti prima di procedere.
Per una release Helm esistente, usa helm upgrade invece di 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"
Prepara le risorse del firewall
La risorsa firewall utilizza una subnet firewall, una subnet di gestione, una risorsa IP pubblica del piano dati e una risorsa IP pubblica di gestione. Salta la creazione per le risorse appropriate già esistenti.
I nomi delle sottoreti devono essere AzureFirewallSubnet e AzureFirewallManagementSubnet. Scegli intervalli di indirizzi all'interno della tua rete virtuale esistente che non si sovrappongano alla sottorete AKS o ad altre sottoreti. I seguenti intervalli di esempio richiedono uno spazio di indirizzamento di rete virtuale che li contenga:
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
Recupera gli ID delle risorse. La risorsa personalizzata richiede gli ID delle risorse Azure, non i valori degli indirizzi IP pubblici.
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)
Crea il firewall
Creare firewall.yaml. L'heredoc senza virgolette espande le variabili dell'ID della risorsa.
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
Puoi opzionalmente aggiungere spec.firewallPolicyReference con l'ID risorsa di una policy firewall esistente. Senza un riferimento, il controller crea una policy gestita.
La creazione può richiedere 10-15 minuti. Aspetta che la Deploymentreason della condizione diventi Ready. Attendere solo lo stato della condizione può terminare mentre la distribuzione di Azure è ancora in corso. Ispeziona le altre condizioni restituite e risolvi gli errori segnalati prima di continuare.
Leggi l'indirizzo IP privato del firewall distribuito dal suo stato:
FW_PRIVATE_IP=$(kubectl get azurefirewall example-firewall --namespace default \
-o jsonpath='{.status.firewallResourceInfo.privateIPAddress}')
echo "$FW_PRIVATE_IP"
Per utilizzare invece un firewall esistente, evita la creazione della AzureFirewall risorsa e utilizza il suo ID della risorsa Azure nell'allegato descritto più avanti in questo articolo. Il firewall esistente deve utilizzare una Firewall Policy, non regole classiche.
Per quel percorso, imposta FW_PRIVATE_IP sull'indirizzo IP privato del firewall esistente prima di configurare il routing:
FW_PRIVATE_IP='<existing-firewall-private-ip>'
Configurare un criterio di sicurezza
La seguente policy seleziona i pod con l'etichetta role: developer e consente le richieste HTTPS ai sottodomini Microsoft e Google utilizzati nel test. Questa politica non sostituisce le regole infrastrutturali di AKS.
Creare 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"
Applicare la policy:
kubectl apply -f security-policy.yaml
Opzioni di regole di rete e di applicazione
Ogni raccolta utilizza refs per selezionare pod, namespace o entrambi, e un action di Allow oppure Deny.
| Collection | Opzioni di configurazione |
|---|---|
networkRuleCollections |
TCP, UDP, ICMP o ANY; porte; indirizzi IP; gruppi IP; tag di servizio; e FQDN. |
applicationRuleCollections |
HTTP, HTTPS o MSSQL; porte; FQDN; Tag FQDN; URL; e categorie web. |
Ad esempio, il seguente spec frammento abilita il proxy DNS e aggiunge una raccolta di regole di rete che seleziona i pod di sviluppo e consente il traffico della porta TCP 443 verso google.com. Non aggiungere questo esempio opzionale alla policy di test solo applicativa senza rivalutare i risultati attesi del test.
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
Una destinazione FQDN in una regola di rete richiede dns.dnsProxy: Enabled. I pod devono anche risolvere il FQDN tramite il firewall affinché il DNS del pod e il DNS del firewall non risolvano indirizzi IP diversi.
Per questo esempio opzionale della regola di rete, allega prima la policy e attendi che sia pronta come descritto in Allega la policy. Poi configura il pod DNS per usare il firewall. Un'opzione è impostare il server DNS della rete virtuale sull'IP privato del firewall:
az network vnet update \
--resource-group "$RESOURCE_GROUP" \
--name "$VNET_NAME" \
--dns-servers "$FW_PRIVATE_IP"
Modificare il DNS della rete virtuale influisce sugli altri carichi di lavoro in quella rete. Registra prima la configurazione DNS originale e riavvia i nodi AKS tramite la procedura di manutenzione affinché rilevino la modifica. In alternativa, configura CoreDNS per inoltrare al firewall. Le regole di applicazione HTTP e HTTPS non richiedono questo percorso di risoluzione DNS.
Le regole applicative possono utilizzare tlsInspection: Enabled. L'ispezione TLS richiede inoltre lo SKU del firewall appropriato, la configurazione dei certificati e l'attendibilità del client. Vedi certificati Firewall di Azure Premium.
Instradare il traffico AKS attraverso il firewall
Importante
Configura il routing prima di allegare una policy. L'associazione disattiva lo SNAT del pod in modo che il firewall veda gli IP sorgente del pod. Senza la route del firewall, i pod possono perdere la connettività in uscita non appena l'associazione entra in vigore.
Quando il controller crea una policy base, consente già la porta TCP 443 al AzureKubernetesService tag di servizio, la porta HTTPS 443 al AzureKubernetesService tag FQDN e la porta HTTPS 443 a *.afc.azure.com.
Se utilizzi un firewall esistente o usi firewallPolicyReference, configura nella tua policy base le necessarie regole di rete AKS e FQDN equivalenti e la porta HTTPS 443 a *.afc.azure.com prima di cambiare il routing. Il controller non modifica una policy base fornita. Mantieni la connettività per i servizi cluster, DNS e pull di immagini. Non modificare direttamente la policy child gestita dal controller.
Per una subnet dedicata alla valutazione senza una tabella di routing esistente, crea la seguente tabella. Usa il FW_PRIVATE_IP recuperato dallo stato del firewall o l'IP privato del firewall esistente.
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
Se una tabella di routing esiste già, aggiungi la route predefinita del firewall a quella tabella invece di sostituirla. Mantieni le altre route necessarie.
L'associazione di una tabella di route non modifica l'AKS outboundType. Se il tuo progetto richiede una migrazione a userDefinedRouting, segui la procedura di migrazione supportata in Personalizzare l’uscita del cluster con i tipi di uscita. Completa la configurazione di uscita e verifica la connettività del cluster prima di continuare.
Allega la polizza
Dopo che il routing è stato configurato, crea attachment.yaml. Questo esempio fa riferimento alla policy e al firewall gestito creati in questa guida.
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
Per un firewall esistente, sostituisci il firewallRef nome e lo spazio dei nomi con un id:
firewallRef:
id: <firewall-resource-id>
| Field | Description |
|---|---|
securityPolicyRefs |
Policy da combinare, identificate per nome e namespace. |
firewallRef |
Required. O il nome e lo spazio dei nomi Kubernetes del firewall gestito, oppure l'ID della risorsa Azure di un firewall esistente. |
aksWorkloadSubnets |
Required. ID delle risorse Azure delle subnet AKS protette dal firewall. |
Aspetta che il motivo della condizione del collegamento Deployment diventi Ready, non solo che il suo stato diventi true. Ispezionare anche le condizioni di risoluzione dei riferimenti e di accettazione.
Aggiornamenti delle policy, precedenza ed eliminazione
IDPS, intelligence sulle minacce, DNS e SNAT sono impostazioni a livello di politica. Se più policy impostano la stessa impostazione, vince la prima policy in securityPolicyRefs.
Se Azure respinge una versione della policy, il controller mantiene la sua ultima versione buona nota, oppure omette tale policy se non ha una versione valida. Non riprova la versione rifiutata solo perché l'errore sottostante scompare. Correggi il problema e cambia l'spec del criterio prima di applicarlo nuovamente.
Rimuovere una policy da securityPolicyRefs prima della cancellazione della risorsa di policy. Altrimenti, la cancellazione può rimanere bloccata. Per ricreare una policy respinta, staccala prima, eliminala, quindi ricreala e ricollegala.
Verificare il traffico dell'applicazione
Crea un pod di test con l'etichetta selezionata dalla policy:
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
Dopo che il pod è in funzione, apri una shell:
kubectl exec --namespace default -it developer-pod -- /bin/bash
Dalla shell del pod, testa le destinazioni consentite:
curl --connect-timeout 10 --max-time 30 https://www.google.com
curl --connect-timeout 10 --max-time 30 https://www.microsoft.com
Poi testa una destinazione non consentita dalla policy di esempio:
curl --connect-timeout 10 --max-time 30 https://www.bing.com
echo "$?"
Nella configurazione di policy isolata prevista, le prime due richieste sono consentite e la richiesta Bing viene negata. Per una richiesta HTTPS negata, il firewall resetta la connessione TLS e curl restituisce il codice 35di uscita . Correla i risultati con i log di Firewall di Azure e con la policy distribuita. Un timeout o un errore TLS da solo non dimostrano quale regola firewall abbia gestito la richiesta.
Le modifiche a regole e etichette possono richiedere alcuni minuti per raggiungere il firewall dopo che la condizione dell'allegato Deployment ha la ragione Ready. Se un risultato non è quello che ti aspetti, lascia tempo per la convergenza e riprova prima di risolvere il problema.
Esci dalla shell del pod quando hai finito:
exit
Verifica che un nuovo pod corrisponda alla policy
Dopo che la policy esistente converge, crea un altro pod con la stessa etichetta:
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
Il nuovo pod etichettato diventa consentito entro pochi secondi senza una distribuzione di Azure Resource Manager. Questo aggiornamento del pod a percorso rapido è separato dal tempo di convergenza per le modifiche di policy o di etichetta.
Configura le impostazioni avanzate delle policy
Un SecurityPolicy può anche definire le seguenti impostazioni. Una policy separata deve essere richiamata dall'allegato prima che abbia effetto. Valuta ogni capacità separatamente invece di applicare ogni esempio all'ambiente di test.
| Setting | Options |
|---|---|
| IDPS |
Disabled, AlertOnly, o AlertAndDeny; sovrascrizioni di firma; e intervalli privati. |
| Intelligence sulle minacce |
Disabled, AlertOnly, oppure AlertAndDeny; CIDR e FQDN consentiti. |
| DNS |
dnsProxy impostato su Enabled o Disabled, con opzionale customNameServers. Senza server personalizzati, la configurazione utilizza DNS di Azure. |
| SNAT |
Always, Never o Exclude. Specifica exclusions solo con Exclude. |
IDPS
Il frammento seguente spec mostra la configurazione IDPS. Un ruleID deve essere un numero, non una stringa tra virgolette. Sostituisci l'ID 2000015 di firma di esempio con l'ID numerico di una firma che desideri sovrascrivere.
idps:
mode: AlertAndDeny
ruleOverrides:
- ruleID: 2000015
mode: AlertOnly
privateIPRanges:
cidrs:
- 10.0.0.0/8
- 192.168.0.0/16
Non configurare bypassList sulla policy figlia gestita dal controller. Azure rifiuta questa impostazione. Se hai bisogno di un bypass IDPS specifico, configura una policy base appropriata di tuo possesso.
Intelligence sulle minacce
Il seguente spec frammento mostra come consentire specifici CIDR e FQDN utilizzando l'intelligence sulle minacce:
threatIntelligence:
mode: AlertAndDeny
allow-list:
cidrs:
- 203.0.113.0/24
- 198.51.100.0/24
fqdns:
- example.com
- example.org
DNS
Il frammento seguente spec abilita il proxy DNS. Configura customNameServers con i tuoi indirizzi del resolver quando il design DNS li richiede.
dns:
dnsProxy: Enabled
customNameServers:
- <dns-server-ip-1>
- <dns-server-ip-2>
SNAT
Il seguente spec frammento esclude gli intervalli privati elencati da SNAT:
snat:
action: Exclude
exclusions:
autoLearnPrivateRanges: Enabled
privateRanges:
- 10.0.0.0/8
- 192.168.0.0/16
Risoluzione dei problemi di configurazione e distribuzione
Inizia con i pod del controller, l'immagine e i log:
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'immagine del controller utilizza il percorso mcr.microsoft.com/firewall/images/azurefirewall-controller con il tag versione selezionato.
Ispeziona le risorse e il loro stato:
kubectl get azurefirewall -A -o yaml
kubectl get securitypolicy -A -o yaml
kubectl get securitypolicyattachment -A -o yaml
| Sintomo | Controlli |
|---|---|
| Errore di autenticazione o HTTP 401 | Verifica la configurazione dell'emittente OIDC, del soggetto federato, del namespace e della workload identity. |
| Errore di autorizzazione o HTTP 403 | Verifica le assegnazioni dei ruoli dell'identità del controller e i loro ambiti. |
| Errore di validazione della risorsa | Ispeziona le condizioni di stato della risorsa. Verifica che i valori dell'IP pubblico e della subnet siano ID validi delle risorse Azure. |
| Errore di distribuzione Azure | Controlla l'errore segnalato e l'Azure Activity Log. Verifica che esistano le risorse indicate e che si trovino nella posizione richiesta. |
| Risultato traffico inatteso | Verifica il routing, la distribuzione degli attachment, i selettori e le altre regole firewall applicabili. |
| La regola di rete FQDN è respinta | Abilita dns.dnsProxy: Enabled nella policy. |
| La regola di rete FQDN non corrisponde | Assicurati che i pod risolvano la destinazione tramite firewall, utilizzando DNS di rete virtuale o inoltro CoreDNS. |
FirewallPolicyChildPolicyIntrusionDetectionBypassTrafficSettingConfigurationError |
Rimuovere bypassList dalla policy gestita dal controller. |
La politica rimane Programmed=False |
Correggi la configurazione rifiutata e modifica le policy spec prima di riapplicarla. Una versione rifiutata non viene riprovata automaticamente. In alternativa, staccalo, cancella e ricrea. |
Cancellare un SecurityPolicy blocco |
Rimuovilo dagli allegati securityPolicyRefs prima di eliminarlo. |
| I pod perdono la connettività internet dopo l'allegamento | Verifica il percorso della 0.0.0.0/0 subnet AKS verso il firewall e le regole AKS e *.afc.azure.com di uscita necessarie. |
| I pod etichettati vengono inaspettatamente negati | Lascia tempo per la convergenza e riprova. Controlla la regione di anteprima, il CNI Azure non-Overlay e kube-system/azure-ip-masq-agent-config. Verifica che il firewall veda l'IP del pod piuttosto che l'IP del nodo. |
Per l'identità del carico di lavoro, ispeziona l'account di servizio e l'ambiente del controller pod:
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"
Controlla l'annotazione azure.workload.identity/client-id dell'account di servizio e l'etichetta del azure.workload.identity/use pod. L'ID client di identità viene fornito tramite AZURE_CLIENT_ID. La configurazione dell'identità del carico di lavoro fornisce anche il tenant (tenant), il file di token federato e l'host di autorità.
Limitazioni dell'anteprima
- Ogni cluster AKS supporta solo uno
SecurityPolicyAttachmente uno Firewall di Azure. Ogni firewall supporta un solo cluster. - L'anteprima ispeziona solo l'uscita dei pod e supporta solo IPv4.
- Azure CNI Overlay non è supportato.
- I pod di rete host utilizzano l'IP del nodo e non possono essere selezionati singolarmente.
- Le implementazioni firewall gestite e Firewall Policy utilizzano di default lo SKU Premium.
- Puoi utilizzare un firewall e una policy standard SKU esistenti per regole basate su etichette, ma IDPS solo Premium, l'ispezione TLS e il filtraggio URL non sono disponibili.
- Una policy base non deve già ereditare da un'altra policy base.
- Puoi modificare la policy genitore tramite il portale Azure. Il controller non annulla quelle modifiche alla policy genitore.
- Non modificare la policy child gestita dal controller tramite il portale Azure. Kubernetes ne è la fonte di verità.
- Un firewall esistente deve utilizzare un criterio dei firewall. Le regole classiche non sono supportate per questa integrazione.
- I CRD vengono utilizzati
v1alpha1e possono cambiare prima della disponibilità generale. - L'anteprima supporta solo Azure public cloud, nelle regioni di anteprima elencate.
Pulire le risorse
Mantieni il controller attivo mentre elimini le risorse che gestisce. Se disinstalli prima il controller, la riconciliazione e la cancellazione delle risorse potrebbero non completarsi.
Esci dalla shell del pod di test ed elimina i pod di test.
kubectl delete pod developer-pod developer-pod-2 --namespace defaultElimina l'allegato e attendi che la cancellazione termini. Poi attendi circa 90 secondi perché il pod SNAT venga ripristinato.
kubectl delete securitypolicyattachment example-attachment --namespace default kubectl wait --for=delete securitypolicyattachment/example-attachment \ --namespace default --timeout=30m sleep 90Ripristina il routing precedente della subnet e la configurazione in uscita richiesta del cluster secondo il tuo piano di rollback. Se la subnet originariamente non aveva una tabella di percorso, rimuovere l'associazione con la tabella di valutazione. Altrimenti, ripristina la sua tabella originale.
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 fiSe hai modificato il DNS di rete virtuale o CoreDNS per l'esempio opzionale della regola di rete, ripristina anche le impostazioni originali. Verifica la connettività del cluster. Non lasciare una route che punti a un firewall che stai per cancellare.
Elimina la policy di valutazione dopo aver rimosso il suo allegato.
kubectl delete securitypolicy example-securitypolicy-rules --namespace defaultSe hai creato il firewall gestito in questa guida, elimina la sua risorsa personalizzata mentre il controller è ancora in esecuzione:
kubectl delete azurefirewall example-firewall --namespace default kubectl wait --for=delete azurefirewall/example-firewall \ --namespace default --timeout=40mLa cancellazione può richiedere 20-30 minuti. Verifica la rimozione del deployment di Azure associato. Non eliminare un firewall esistente che hai specificato tramite l'ID della risorsa.
Dopo che la cancellazione delle risorse gestite è completata, disinstalla il controller.
helm uninstall azfw-controller --namespace "$HELM_NAMESPACE"Elimina lo spazio dei nomi del controller solo se lo hai creato esclusivamente per questa guida e non contiene risorse di cui hai bisogno.
I comandi precedenti non eliminano il cluster AKS, la rete virtuale, le sottonet, le risorse IP pubbliche, la tabella di instradamento, l'identità o l'assegnazione dei ruoli. Rimuovere solo le risorse che hai creato esclusivamente per questa valutazione dopo aver verificato che nessun altro carico di lavoro le utilizzi. In particolare, mantenere le risorse di rete preesistenti e ripristinare la loro configurazione originale.