Beheer het verkeer van het verkeer voor het verkeer voor clusterknooppunten in Azure Kubernetes Service (AKS)

Dit artikel bevat de benodigde details waarmee u uitgaand verkeer van uw Azure Kubernetes Service (AKS) kunt beveiligen. Het bevat de clustervereisten voor een basis-AKS-implementatie en aanvullende vereisten voor optionele addons en functies. Er wordt aan het einde een voorbeeld gegeven voor het configureren vandeze vereisten met Azure Firewall. U kunt deze informatie echter toepassen op elke uitgaande beperkingsmethode of elk apparaat.

Achtergrond

AKS-clusters worden geïmplementeerd in een virtueel netwerk. Dit netwerk kan worden beheerd (gemaakt door AKS) of aangepast (vooraf geconfigureerd door de gebruiker). In beide gevallen heeft het cluster uitgaande afhankelijkheden van services buiten dat virtuele netwerk (de service heeft geen binnenkomende afhankelijkheden).

Voor beheer- en operationele doeleinden moeten knooppunten in een AKS-cluster toegang hebben tot bepaalde poorten en FQDN's (Fully Qualified Domain Names). Deze eindpunten zijn vereist om de knooppunten te laten communiceren met de API-server of om kernonderdelen van kubernetes-clusters en beveiligingsupdates voor knooppunten te downloaden en installeren. Het cluster moet bijvoorbeeld installatie van basissysteemcontainers uit Microsoft Container Registry (MCR).

De uitgaande AKS-afhankelijkheden worden bijna volledig gedefinieerd met FQDN's, die geen statische adressen achter zich hebben. Het ontbreken van statische adressen betekent dat netwerkbeveiligingsgroepen niet kunnen worden gebruikt om uitgaand verkeer van een AKS-cluster te vergrendelen.

Standaard hebben AKS-clusters onbeperkte uitgaande (uitgaande) internettoegang. Met dit niveau van netwerktoegang kunnen knooppunten en services die u hebt uitgevoerd, naar behoefte toegang krijgen tot externe resources. Als u het toegangsverkeer wilt beperken, moet een beperkt aantal poorten en adressen toegankelijk zijn voor het onderhouden van goede clusteronderhoudstaken. De eenvoudigste oplossing voor het beveiligen van uitgaande adressen is het gebruik van een firewallapparaat dat uitgaand verkeer kan beheren op basis van domeinnamen. Azure Firewall kan bijvoorbeeld uitgaand HTTP- en HTTPS-verkeer beperken op basis van de FQDN van de bestemming. U kunt ook de firewall en beveiligingsregels van uw voorkeur configureren om deze vereiste poorten en adressen toe te staan.

Vereiste uitgaande netwerkregels en FQDN's voor AKS-clusters

De volgende netwerk- en FQDN-/toepassingsregels zijn vereist voor een AKS-cluster. U kunt deze gebruiken als u een andere oplossing dan een Azure Firewall.

• IP-adresafhankelijkheden zijn voor niet-HTTP/S-verkeer (zowel TCP- als UDP-verkeer)
• FQDN HTTP/HTTPS-eindpunten kunnen in uw firewallapparaat worden geplaatst.
• HTTP/HTTPS-eindpunten met jokertekens zijn afhankelijkheden die met uw AKS-cluster kunnen variëren op basis van een aantal kwalificaties.
• AKS maakt gebruik van een toegangscontroller om de FQDN als een omgevingsvariabele te injecteren in alle implementaties onder kube-system en gatekeeper-system, die ervoor zorgt dat alle systeemcommunicatie tussen knooppunten en DE API-server gebruikmaakt van de API-server-FQDN en niet het IP-adres van de API-server.
• Als u een app of oplossing hebt die moet communiceren met de API-server, moet u een extra netwerkregel toevoegen om TCP-communicatie met poort 443 van het IP-adres van uw API-server toe te staan.
• In zeldzame gevallen kan het IP-adres van uw API-server worden gewijzigd als er een onderhoudsbewerking wordt uitgevoerd. Geplande onderhoudsbewerkingen die het IP-adres van de API-server kunnen wijzigen, worden altijd vooraf gecommuniceerd.

Wereldwijd vereiste netwerkregels voor Azure

De vereiste netwerkregels en IP-adresafhankelijkheden zijn:

Azure Global required FQDN /application rules (Wereldwijd vereiste FQDN-FQDN van Azure/ toepassingsregels)

De volgende FQDN-/toepassingsregels zijn vereist:

Azure China 21Vianet netwerkregels maken

De vereiste netwerkregels en IP-adresafhankelijkheden zijn:

Azure China 21Vianet FQDN/toepassingsregels maken

De volgende FQDN-/toepassingsregels zijn vereist:

Vereiste netwerkregels voor Azure voor de Amerikaanse overheid

De vereiste netwerkregels en IP-adresafhankelijkheden zijn:

Vereiste FQDN-/toepassingsregels voor Azure voor de Amerikaanse overheid

De volgende FQDN-/toepassingsregels zijn vereist:

Optionele aanbevolen FQDN/toepassingsregels voor AKS-clusters

De volgende FQDN-/toepassingsregels zijn optioneel, maar aanbevolen voor AKS-clusters:

Als u ervoor kiest om deze FQDN's te blokkeren of niet toe te staan, ontvangen de knooppunten alleen updates van het besturingssysteem wanneer u een upgrade van de knooppuntafbeelding of clusterupgrade hebt uitgevoerd.

AKS-clusters met GPU

Vereiste FQDN/toepassingsregels

De volgende FQDN-/toepassingsregels zijn vereist voor AKS-clusters met GPU:

Windows servergebaseerde knooppuntgroepen

Vereiste FQDN/toepassingsregels

De volgende FQDN-/toepassingsregels zijn vereist voor het gebruik van Windows servergebaseerde knooppuntgroepen:

AKS-addons en integraties

Azure Monitor voor containers

Er zijn twee opties om toegang te bieden tot Azure Monitor voor containers. U kunt de Azure Monitor ServiceTag toestaan of toegang verlenen tot de vereiste FQDN-/toepassingsregels.

Vereiste netwerkregels

De volgende FQDN-/toepassingsregels zijn vereist:

Vereiste FQDN/toepassingsregels

De volgende FQDN-/toepassingsregels zijn vereist voor AKS-clusters Azure Monitor voor containers zijn ingeschakeld:

Azure Policy

Vereiste FQDN/toepassingsregels

De volgende FQDN-/toepassingsregels zijn vereist voor AKS-clusters Azure Policy ingeschakeld.

Azure China 21Vianet FQDN/toepassingsregels maken

De volgende FQDN-/toepassingsregels zijn vereist voor AKS-clusters Azure Policy ingeschakeld.

Vereiste FQDN/toepassingsregels voor Azure US Government

De volgende FQDN-/toepassingsregels zijn vereist voor AKS-clusters Azure Policy ingeschakeld.

Clusterextensies

Vereiste FQDN/toepassingsregels

De volgende FQDN-/toepassingsregels zijn vereist voor het gebruik van clusterextensies op AKS-clusters.

Vereiste FQDN/toepassingsregels voor Azure US Government

De volgende FQDN-/toepassingsregels zijn vereist voor het gebruik van clusterextensies op AKS-clusters.

Het verkeer voor verkeer dat uit de omgeving komt beperken met behulp van Azure Firewall

Azure Firewall biedt een Azure Kubernetes Service ( AzureKubernetesService ) FQDN-tag om deze configuratie te vereenvoudigen.

Hieronder vindt u een voorbeeldarchitectuur van de implementatie:

• Openbaar toegangsgressie wordt gedwongen om door firewallfilters te stromen
  • AKS-agentknooppunten worden geïsoleerd in een toegewezen subnet.
  • Azure Firewall wordt geïmplementeerd in een eigen subnet.
  • Met een DNAT-regel wordt het openbare IP-adres van de FW omgezet in het IP-adres van de LB-front-end.
• Uitgaande aanvragen starten vanaf agentknooppunten naar het interne IP Azure Firewall met behulp van een door de gebruiker gedefinieerde route
  • Aanvragen van AKS-agentknooppunten volgen een UDR die is geplaatst op het subnet waar het AKS-cluster in is geïmplementeerd.
  • Azure Firewall het virtuele netwerk uit vanaf een openbare IP-front-end
  • Toegang tot het openbare internet of andere Azure-services loopt van en naar het front-end-IP-adres van de firewall
  • Toegang tot het AKS-besturingsvlak wordt optioneel beveiligd door geautoriseerde IP-bereiken van de API-server,waaronder het openbare front-end-IP-adres van de firewall.
• Intern verkeer
  • U kunt in plaats van of naast een openbare Load Balancer ook een interne Load Balancer gebruiken voor intern verkeer, dat u ook op een eigen subnet kunt isoleren.

In de onderstaande stappen wordt gebruik gemaakt van de FQDN-tag van Azure Firewall om het uitgaande verkeer van het AKS-cluster te beperken en een voorbeeld te geven van het configureren van openbaar inkomende verkeer via de AzureKubernetesService firewall.

Configuratie instellen via omgevingsvariabelen

Definieer een set omgevingsvariabelen die moeten worden gebruikt bij het maken van resources.

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"

Een virtueel netwerk met meerdere subnetten maken

Een virtueel netwerk inrichten met twee afzonderlijke subnetten, één voor het cluster, één voor de firewall. Desgewenst kunt u er ook een maken voor intern service-ingress.

Maak een resourcegroep voor alle resources.

# Create Resource Group

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

Maak een virtueel netwerk met twee subnetten voor het hosten van het AKS-cluster en de Azure Firewall. Elk heeft een eigen subnet. Laten we beginnen met het AKS-netwerk.

# 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

Een Azure Firewall maken en instellen met een UDR

Azure Firewall regels voor binnenkomende en uitgaande verkeer moeten worden geconfigureerd. Het belangrijkste doel van de firewall is om organisaties in staat te stellen gedetailleerde regels voor in- en uitverkeer naar en uit het AKS-cluster te configureren.

Maak een openbare IP-resource van een standaard-SKU die wordt gebruikt als Azure Firewall front-endadres.

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

Registreer de preview-cli-extensie om een nieuwe 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

Het IP-adres dat u eerder hebt gemaakt, kan nu worden toegewezen aan de front-end van de firewall.

# 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

Wanneer de vorige opdracht is geslaagd, moet u het front-end-IP-adres van de firewall later opslaan voor configuratie.

# 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)

Een UDR maken met een hop die u wilt Azure Firewall

Azure routeert automatisch verkeer tussen Azure-subnetten, virtuele netwerken en on-premises netwerken. Als u de standaardroutering van Azure wilt wijzigen, doet u dit door een routetabel te maken.

Maak een lege routetabel die moet worden gekoppeld aan een bepaald subnet. De routetabel definieert de volgende hop als de Azure Firewall hierboven is gemaakt. Elk subnet kan zijn gekoppeld aan geen enkele of één routetabel.

# 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
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

Zie documentatie over routetabel voor virtuele netwerken over hoe u de standaardsysteemroutes van Azure kunt overschrijven of aanvullende routes kunt toevoegen aan de routetabel van een subnet.

Firewallregels toevoegen

Hieronder vindt u drie netwerkregels die u kunt gebruiken om te configureren op uw firewall. Mogelijk moet u deze regels aanpassen op basis van uw implementatie. De eerste regel staat toegang tot poort 9000 toe via TCP. De tweede regel staat toegang tot poort 1194 en 123 toe via UDP (als u implementeert in Azure China 21Vianet, hebt u mogelijk meer nodig). Beide regels staan alleen verkeer toe dat is bestemd voor de AZURE-regio-CIDR die we gebruiken, in dit geval VS - oost. Ten slotte voegen we een derde netwerkregel toe die poort 123 opent naar FQDN via UDP (het toevoegen van een FQDN als een netwerkregel is een van de specifieke functies van Azure Firewall en u moet deze aanpassen wanneer u uw eigen opties ntp.ubuntu.com gebruikt).

Na het instellen van de netwerkregels voegen we ook een toepassingsregel toe met behulp van de die betrekking heeft op alle benodigde FQDN's die toegankelijk zijn AzureKubernetesService via TCP-poort 443 en poort 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

Zie Azure Firewall documentatie voor meer informatie over de Azure Firewall service.

De routetabel koppelen aan AKS

Als u het cluster wilt koppelen aan de firewall, moet het toegewezen subnet voor het subnet van het cluster verwijzen naar de hierboven gemaakte routetabel. U kunt een associatie tot stand brengen door een opdracht uit te geven aan het virtuele netwerk met zowel het cluster als de firewall om de routetabel van het subnet van het cluster bij te werken.

# 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

AKS met uitgaand type UDR implementeren in het bestaande netwerk

Nu kan een AKS-cluster worden geïmplementeerd in het bestaande virtuele netwerk. We gebruiken ook uitgaand type userDefinedRouting . Deze functie zorgt ervoor dat uitgaand verkeer wordt geforceerd via de firewall en dat er geen andere uitgaande paden bestaan (standaard kan het uitgaande type Load Balancer worden gebruikt).

Een service-principal maken met toegang tot inrichten binnen het bestaande virtuele netwerk

Een clusteridentiteit (beheerde identiteit of service-principal) wordt door AKS gebruikt om clusterbronnen te maken. Een service-principal die tijdens het maken wordt doorgegeven, wordt gebruikt om onderliggende AKS-resources te maken, zoals Storage-resources, -IP's en load balancers die worden gebruikt door AKS (u kunt in plaats daarvan ook een beheerde identiteit gebruiken). Als u hieronder niet de juiste machtigingen hebt gekregen, kunt u het AKS-cluster niet inrichten.

# Create SP and Assign Permission to Virtual Network

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

Vervang nu en hieronder door de appid van de service-principal en het wachtwoord van de service-principal die automatisch zijn APPID gegenereerd door de vorige PASSWORD opdrachtuitvoer. We verwijzen naar de resource-id van het VNET om de machtigingen aan de service-principal te verlenen, zodat AKS er resources in kan implementeren.

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"

U kunt hier de gedetailleerde machtigingen controleren die vereist zijn.

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"

AKS implementeren

Ten slotte kan het AKS-cluster worden geïmplementeerd in het bestaande subnet dat we voor het cluster hebben toegewezen. Het doelsubnet waarin moet worden geïmplementeerd, wordt gedefinieerd met de omgevingsvariabele , $SUBNETID . We hebben de variabele in $SUBNETID de vorige stappen niet definieert. Als u de waarde voor de subnet-id wilt instellen, kunt u de volgende opdracht gebruiken:

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

U definieert het uitgaande type om de UDR te gebruiken die al op het subnet bestaat. Met deze configuratie kan AKS de installatie en IP-inrichting voor de 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

Toegang van ontwikkelaars tot de API-server inschakelen

Als u in de vorige stap geautoriseerde IP-bereiken voor het cluster hebt gebruikt, moet u de IP-adressen van de hulpprogramma's voor ontwikkelaars toevoegen aan de AKS-clusterlijst met goedgekeurde IP-bereiken om van hieruit toegang te krijgen tot de API-server. Een andere optie is om een jumpbox te configureren met de benodigde hulpprogramma's in een afzonderlijk subnet in het virtuele netwerk van de firewall.

Voeg nog een IP-adres toe aan de goedgekeurde reeksen met de volgende opdracht

# 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

Gebruik de opdracht [az aks get-credentials][az-aks-get-credentials] om te configureren dat er verbinding wordt gemaakt met uw zojuist gemaakte kubectl Kubernetes-cluster.

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

Een openbare service implementeren

U kunt nu beginnen met het blootstellen van services en het implementeren van toepassingen in dit cluster. In dit voorbeeld geven we een openbare service weer, maar u kunt er ook voor kiezen om een interne service beschikbaar te maken via interne load balancer.

Implementeer de Azure-stem-app door de onderstaande yaml te kopiëren naar een bestand met de naam 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

Implementeer de service door het volgende uit te uitvoeren:

kubectl apply -f example.yaml

Een DNAT-regel toevoegen aan Azure Firewall

Als u binnenkomende connectiviteit wilt configureren, moet er een DNAT-regel naar de Azure Firewall. Als u de connectiviteit met uw cluster wilt testen, wordt er een regel gedefinieerd voor het openbare IP-adres van de front-end van de firewall om te worden gerouteerd naar het interne IP-adres dat wordt blootgesteld door de interne service.

Het doeladres kan worden aangepast omdat dit de poort op de firewall is die moet worden gebruikt. Het vertaalde adres moet het IP-adres van de interne load balancer. De vertaalde poort moet de ontsluisde poort voor uw Kubernetes-service zijn.

U moet het interne IP-adres opgeven dat is toegewezen aan de load balancer gemaakt door de Kubernetes-service. Haal het adres op door het volgende uit te uitvoeren:

kubectl get services

Het benodigde IP-adres wordt weergegeven in de kolom EXTERNAL-IP, vergelijkbaar met het volgende.

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

Haal het IP-adres van de service op door het volgende uit te uitvoeren:

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

Voeg de NAT-regel toe door het volgende uit te uitvoeren:

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

Connectiviteit valideren

Navigeer naar Azure Firewall front-end-IP-adres in een browser om de connectiviteit te valideren.

U ziet nu de AKS-stem-app. In dit voorbeeld was het openbare IP-adres van de 52.253.228.132 firewall.

Resources opschonen

Als u Azure-resources wilt ops schonen, verwijdert u de AKS-resourcegroep.

az group delete -g $RG

Volgende stappen

In dit artikel hebt u geleerd welke poorten en adressen moeten worden toegestaan als u het toegangsverkeer voor het cluster wilt beperken. U hebt ook gezien hoe u uw uitgaande verkeer kunt beveiligen met Azure Firewall.

Indien nodig kunt u de bovenstaande stappen generaliseren om het verkeer door testuren naar de uitgaande oplossing van uw userDefinedRoute voorkeur,volgens de documentatie voor uitgaand type .

Zie Verkeer tussen pods beveiligen met behulp van netwerkbeleid in AKS als u de communicatie tussen pods tussen zichzelf en East-West het cluster wilt beperken.