Använda en intern lastbalanserare med Azure Kubernetes Service (AKS)

Artikel
01/29/2024

Du kan skapa och använda en intern lastbalanserare för att begränsa åtkomsten till dina program i Azure Kubernetes Service (AKS). En intern lastbalanserare har ingen offentlig IP-adress och gör en Kubernetes-tjänst endast tillgänglig för program som kan nå den privata IP-adressen. Dessa program kan finnas i samma VNET eller i ett annat VNET via VNET-peering. Den här artikeln visar hur du skapar och använder en intern lastbalanserare med AKS.

Kommentar

Azure Load Balancer finns i två SKU:er: Basic och Standard. Standard-SKU:n används som standard när du skapar ett AKS-kluster. När du skapar en LoadBalancer-tjänsttyp får du samma lastbalanseraretyp som när du etablerade klustret. Mer information finns i Azure Load Balancer SKU-jämförelse.

Innan du börjar

Den här artikeln förutsätter att du har ett befintligt AKS-kluster. Om du behöver ett AKS-kluster kan du skapa ett med hjälp av Azure CLI, Azure PowerShell eller Azure-portalen.
Du behöver Azure CLI version 2.0.59 eller senare. Kör az --version för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.
Om du vill använda ett befintligt undernät eller en resursgrupp behöver AKS-klusteridentiteten behörighet att hantera nätverksresurser. Mer information finns i Använda kubenet-nätverk med dina egna IP-adressintervall i AKS eller Konfigurera Azure CNI-nätverk i AKS. Om du konfigurerar lastbalanseraren för att använda en IP-adress i ett annat undernät kontrollerar du att AKS-klusteridentiteten också har läsbehörighet till undernätet.
- Mer information om behörigheter finns i Delegera AKS-åtkomst till andra Azure-resurser.

Skapa en intern lastbalanserare

Skapa ett tjänstmanifest med namnet internal-lb.yaml med tjänsttypen LoadBalancer och anteckningen azure-load-balancer-internal .

apiVersion: v1
kind: Service
metadata:
  name: internal-app
  annotations:
    service.beta.kubernetes.io/azure-load-balancer-internal: "true"
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: internal-app

Distribuera den interna lastbalanseraren med kommandot kubectl apply . Det här kommandot skapar en Azure-lastbalanserare i nodresursgruppen som är ansluten till samma virtuella nätverk som ditt AKS-kluster.
```
kubectl apply -f internal-lb.yaml
```
Visa tjänstinformationen kubectl get service med kommandot .
```
kubectl get service internal-app
```
IP-adressen för den interna lastbalanseraren visas i EXTERNAL-IP kolumnen, enligt följande exempelutdata. I det här sammanhanget refererar Externt till lastbalanserarens externa gränssnitt. Det betyder inte att den tar emot en offentlig, extern IP-adress. Den här IP-adressen tilldelas dynamiskt från samma undernät som AKS-klustret.
```
NAME           TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
internal-app   LoadBalancer   10.0.248.59   10.240.0.7    80:30555/TCP   2m
```

Ange en IP-adress

När du anger en IP-adress för lastbalanseraren måste den angivna IP-adressen finnas i samma undernät som AKS-klustret, men den kan inte redan tilldelas till en resurs. Du bör till exempel inte använda en IP-adress i intervallet som är avsett för Kubernetes-undernätet i AKS-klustret.

Du kan använda az network vnet subnet list Azure CLI-kommandot eller PowerShell-cmdleten Get-AzVirtualNetworkSubnetConfig för att hämta undernäten i det virtuella nätverket.

Mer information om undernät finns i Lägga till en nodpool med ett unikt undernät.

Om du vill använda en specifik IP-adress med lastbalanseraren har du två alternativ: ange tjänstanteckningar eller lägga till egenskapen LoadBalancerIP i YAML-manifestet för lastbalanseraren.

Viktigt!

Att lägga till egenskapen LoadBalancerIP i YAML-manifestet för lastbalanseraren är inaktuellt för att följa uppströms Kubernetes. Även om den aktuella användningen förblir densamma och befintliga tjänster förväntas fungera utan ändringar rekommenderar vi starkt att du anger tjänstanteckningar i stället.

Ange tjänstanteckningar
Lägg till egenskapen LoadBalancerIP i YAML-manifestet för lastbalanseraren

Ange tjänstanteckningar med för service.beta.kubernetes.io/azure-load-balancer-ipv4 en IPv4-adress och service.beta.kubernetes.io/azure-load-balancer-ipv6 för en IPv6-adress.

apiVersion: v1
kind: Service
metadata:
  name: internal-app
  annotations:
    service.beta.kubernetes.io/azure-load-balancer-ipv4: 10.240.0.25
    service.beta.kubernetes.io/azure-load-balancer-internal: "true"
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: internal-app

Lägg till egenskapen Service.Spec.LoadBalancerIP i YAML-manifestet för lastbalanseraren. Det här fältet är inaktuellt för att följa uppströms Kubernetes och det kan inte ha stöd för dubbla staplar. Den aktuella användningen är densamma och befintliga tjänster förväntas fungera utan ändringar.
```
apiVersion: v1
kind: Service
metadata:
  name: internal-app
  annotations:
    service.beta.kubernetes.io/azure-load-balancer-internal: "true"
spec:
  type: LoadBalancer
  loadBalancerIP: 10.240.0.25
  ports:
  - port: 80
  selector:
    app: internal-app
```

Visa tjänstinformationen kubectl get service med kommandot .

kubectl get service internal-app

IP-adressen i EXTERNAL-IP kolumnen bör återspegla din angivna IP-adress, enligt följande exempelutdata:

NAME           TYPE           CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
internal-app   LoadBalancer   10.0.184.168   10.240.0.25   80:30225/TCP   4m

Mer information om hur du konfigurerar lastbalanseraren i ett annat undernät finns i Ange ett annat undernät

Anslut Azure Private Link-tjänsten till en intern lastbalanserare

Innan du börjar

Du behöver Kubernetes version 1.22.x eller senare.
Du behöver en befintlig resursgrupp med ett VNet och undernät. Den här resursgruppen är den plats där du skapar den privata slutpunkten. Om du inte har dessa resurser kan du läsa Skapa ett virtuellt nätverk och undernät.

Skapa en Private Link-tjänstanslutning

Skapa ett tjänstmanifest med namnet internal-lb-pls.yaml med tjänsttypen LoadBalancer och anteckningarna azure-load-balancer-internal och azure-pls-create . Fler alternativ finns i designdokumentet för Azure Private Link Service Integration .

apiVersion: v1
kind: Service
metadata:
  name: internal-app
  annotations:
    service.beta.kubernetes.io/azure-load-balancer-internal: "true"
    service.beta.kubernetes.io/azure-pls-create: "true"
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: internal-app

Distribuera den interna lastbalanseraren med kommandot kubectl apply . Det här kommandot skapar en Azure-lastbalanserare i nodresursgruppen som är ansluten till samma virtuella nätverk som ditt AKS-kluster. Det skapar också ett Private Link Service-objekt som ansluter till klientdels-IP-konfigurationen för lastbalanseraren som är associerad med Kubernetes-tjänsten.
```
kubectl apply -f internal-lb-pls.yaml
```
Visa tjänstinformationen kubectl get service med kommandot .
```
kubectl get service internal-app
```
IP-adressen för den interna lastbalanseraren visas i EXTERNAL-IP kolumnen, enligt följande exempelutdata. I det här sammanhanget refererar Externt till lastbalanserarens externa gränssnitt. Det betyder inte att den tar emot en offentlig, extern IP-adress.
```
NAME           TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
internal-app   LoadBalancer   10.125.17.53  10.125.0.66   80:30430/TCP   64m
```

Visa information om Private Link Service-objektet med hjälp av az network private-link-service list kommandot .

# Create a variable for the node resource group

AKS_MC_RG=$(az aks show -g myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv)

# View the details of the Private Link Service object

az network private-link-service list -g $AKS_MC_RG --query "[].{Name:name,Alias:alias}" -o table

Dina utdata bör se ut ungefär som följande exempelutdata:

Name      Alias
--------  -------------------------------------------------------------------------
pls-xyz   pls-xyz.abc123-defg-4hij-56kl-789mnop.eastus2.azure.privatelinkservice

Skapa en privat slutpunkt till Private Link-tjänsten

Med en privat slutpunkt kan du privat ansluta till kubernetes-tjänstobjektet via private link-tjänsten som du skapade.

Skapa den privata slutpunkten med kommandot az network private-endpoint create .

# Create a variable for the private link service

AKS_PLS_ID=$(az network private-link-service list -g $AKS_MC_RG --query "[].id" -o tsv)

# Create the private endpoint

$ az network private-endpoint create \
    -g myOtherResourceGroup \
    --name myAKSServicePE \
    --vnet-name myOtherVNET \
    --subnet pe-subnet \
    --private-connection-resource-id $AKS_PLS_ID \
    --connection-name connectToMyK8sService

PLS-anpassningar via anteckningar

Följande är anteckningar som kan användas för att anpassa PLS-resursen.

Annotation	Värde	beskrivning	Obligatoriskt	Standardvärde
`service.beta.kubernetes.io/azure-pls-create`	`"true"`	Booleskt värde som anger om en PLS behöver skapas.	Obligatoriskt
`service.beta.kubernetes.io/azure-pls-name`	`<PLS name>`	Sträng som anger namnet på den PLS-resurs som ska skapas.	Valfritt	`"pls-<LB frontend config name>"`
`service.beta.kubernetes.io/azure-pls-resource-group`	`Resource Group name`	Sträng som anger namnet på resursgruppen där PLS-resursen ska skapas	Valfritt	`MC_ resource`
`service.beta.kubernetes.io/azure-pls-ip-configuration-subnet`	`<Subnet name>`	Sträng som anger det undernät som PLS ska distribueras till. Det här undernätet måste finnas i samma virtuella nätverk som serverdelspoolen. PLS NAT IP-adresser allokeras i det här undernätet.	Valfritt	Om `service.beta.kubernetes.io/azure-load-balancer-internal-subnet`används detta ILB-undernät. Annars används standardundernätet från konfigurationsfilen.
`service.beta.kubernetes.io/azure-pls-ip-configuration-ip-address-count`	`[1-8]`	Totalt antal privata NAT-IP-adresser som ska allokeras.	Valfritt	1
`service.beta.kubernetes.io/azure-pls-ip-configuration-ip-address`	`"10.0.0.7 ... 10.0.0.10"`	En blankstegsavgränsad lista över statiska IPv4-IP-adresser som ska allokeras. (IPv6 stöds inte just nu.) Det totala antalet IP-adresser får inte vara större än det ip-antal som anges i `service.beta.kubernetes.io/azure-pls-ip-configuration-ip-address-count`. Om det finns färre IP-adresser angivna allokeras resten dynamiskt. Den första IP-adressen i listan anges som `Primary`.	Valfritt	Alla IP-adresser allokeras dynamiskt.
`service.beta.kubernetes.io/azure-pls-fqdns`	`"fqdn1 fqdn2"`	En blankstegsavgränsad lista över fqdns som är associerade med PLS.	Valfritt	`[]`
`service.beta.kubernetes.io/azure-pls-proxy-protocol`	`"true"` eller `"false"`	Booleskt värde som anger om TCP PROXY-protokollet ska aktiveras på PLS för att skicka anslutningsinformation, inklusive länk-ID och källans IP-adress. Observera att serverdelstjänsten MÅSTE ha stöd för PROXY-protokollet, annars misslyckas anslutningarna.	Valfritt	`false`
`service.beta.kubernetes.io/azure-pls-visibility`	`"sub1 sub2 sub3 … subN"` eller `"*"`	En blankstegsavgränsad lista över Azure-prenumerations-ID:t som tjänsten private link är synlig för. Använd `"*"` för att exponera PLS för alla subs (minst restriktiv).	Valfritt	Tom lista `[]` som endast anger rollbaserad åtkomstkontroll: Den här privata länktjänsten är endast tillgänglig för personer med rollbaserad åtkomstkontrollbehörighet i din katalog. (Mest restriktiv)
`service.beta.kubernetes.io/azure-pls-auto-approval`	`"sub1 sub2 sub3 … subN"`	En blankstegsavgränsad lista över Azure-prenumerations-ID:t. Detta gör att PE-anslutningsbegäranden från de prenumerationer som anges i PLS godkänns automatiskt. Detta fungerar bara när synligheten är inställd på "*".	Valfritt	`[]`

Använda privata nätverk

När du skapar AKS-klustret kan du ange avancerade nätverksinställningar. Med de här inställningarna kan du distribuera klustret till ett befintligt virtuellt Azure-nätverk och undernät. Du kan till exempel distribuera ditt AKS-kluster till ett privat nätverk som är anslutet till din lokala miljö och köra tjänster som endast är tillgängliga internt.

Mer information finns i konfigurera dina egna virtuella nätverksundernät med Kubenet eller med Azure CNI.

Du behöver inte göra några ändringar i föregående steg för att distribuera en intern lastbalanserare som använder ett privat nätverk i ett AKS-kluster. Lastbalanseraren skapas i samma resursgrupp som aks-klustret, men den är i stället ansluten till ditt privata virtuella nätverk och undernät, som du ser i följande exempel:

$ kubectl get service internal-app

NAME           TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
internal-app   LoadBalancer   10.1.15.188   10.0.0.35     80:31669/TCP   1m

Kommentar

Klusteridentiteten som används av AKS-klustret måste minst ha rollen Nätverksdeltagare i den virtuella nätverksresursen. Du kan visa klusteridentiteten az aks show med hjälp av kommandot, till exempel az aks show --resource-group <resource-group-name> --name <cluster-name> --query "identity". Du kan tilldela rollen Nätverksdeltagare med hjälp av az role assignment create kommandot, till exempel az role assignment create --assignee <identity-resource-id> --scope <virtual-network-resource-id> --role "Network Contributor".

Om du vill definiera en anpassad roll i stället behöver du följande behörigheter:

Microsoft.Network/virtualNetworks/subnets/join/action
Microsoft.Network/virtualNetworks/subnets/read

Mer information finns i Lägga till, ändra eller ta bort ett virtuellt nätverksundernät.

Ange ett annat undernät

Lägg till anteckningen azure-load-balancer-internal-subnet i tjänsten för att ange ett undernät för lastbalanseraren. Det angivna undernätet måste finnas i samma virtuella nätverk som aks-klustret. När den distribueras är lastbalanserarens EXTERNAL-IP adress en del av det angivna undernätet.

apiVersion: v1
kind: Service
metadata:
  name: internal-app
  annotations:
    service.beta.kubernetes.io/azure-load-balancer-internal: "true"
    service.beta.kubernetes.io/azure-load-balancer-internal-subnet: "apps-subnet"
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: internal-app

Ta bort lastbalanseraren

Lastbalanseraren tas bort när alla dess tjänster tas bort.

Precis som kubectl delete service internal-appmed alla Kubernetes-resurser kan du ta bort en tjänst direkt, till exempel , som även tar bort den underliggande Azure-lastbalanseraren.

Nästa steg

Mer information om Kubernetes-tjänster finns i dokumentationen om Kubernetes-tjänster.

Använda en intern lastbalanserare med Azure Kubernetes Service (AKS)

Innan du börjar

Skapa en intern lastbalanserare

Ange en IP-adress

Anslut Azure Private Link-tjänsten till en intern lastbalanserare

Innan du börjar

Skapa en Private Link-tjänstanslutning

Skapa en privat slutpunkt till Private Link-tjänsten

PLS-anpassningar via anteckningar

Använda privata nätverk

Ange ett annat undernät

Ta bort lastbalanseraren

Nästa steg

Ytterligare resurser