Cloud & IT Cert Prep · Lektion

EKS-nätverk: VPC CNI och lastbalansering

Använd plugin-programmet Amazon VPC CNI så att pods får inbyggda VPC-IP-adresser och exponera tjänster med AWS Load Balancer Controller.

Lektion 3 av 413 steg

EKS-nätverk: VPC CNI och lastbalansering är en gratis lektion i Cloud & IT Cert Prep på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Cloud & IT Cert Prep, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Cloud & IT Cert Prep innehåller totalt 4 lektioner.

Grunderna i Kubernetes-nätverk

Kubernetes kräver att varje podd har en unik, routningsbar IP-adress och att poddar kan kommunicera med varandra utan NAT. Plugin-programmet Container Network Interface (CNI) ansvarar för att tilldela IP-adresser och konfigurera nätverksrutter på arbetsnoder. Olika Kubernetes-plattformar använder olika CNI-implementationer; AWS använder Amazon VPC CNI plugin för att integrera Kubernetes-nätverk direkt med VPC-lagret.

Amazon VPC CNI-plugin

Amazon VPC CNI plugin tilldelar varje podd en IP-adress direkt från VPC:ns CIDR-intervall för subnätet. Det innebär att poddar är fullvärdiga VPC-resurser — de kan nås av andra VPC-resurser, lokala system via VPN/Direct Connect och säkerhetsgrupper utan översättning i ett overlay-nätverk. Varje EC2-arbetsnod upprätthåller en pool med sekundära privata IP-adresser (en per ENI-plats) som tilldelas poddar när de schemaläggs.

# Check the VPC CNI version installed in your cluster
kubectl describe daemonset aws-node -n kube-system | grep Image

# View the secondary IPs assigned to a node
aws ec2 describe-network-interfaces \
  --filters 'Name=attachment.instance-id,Values=i-0abcdef1234567890' \
  --query 'NetworkInterfaces[].PrivateIpAddresses[].PrivateIpAddress'

ENI och varm IP-adresspool

VPC CNI-pluginet upprätthåller en varm pool med förallokerade IP-adresser på varje nod för att möjliggöra snabb schemaläggning av poddar. När en nod startar ansluter CNI flera ENI:er och tilldelar sekundära IP-adresser upp till värdena för miljövariablerna WARM_IP_TARGET eller MINIMUM_IP_TARGET. Det maximala antalet poddar som en nod kan köra begränsas därför av instansens antal ENI:er multiplicerat med antalet IP-adresser per ENI, vilket varierar beroende på instanstyp.

# Check maximum pods supported by an instance type
aws ec2 describe-instance-types \
  --instance-types m5.large \
  --query 'InstanceTypes[].NetworkInfo.{MaxENIs:MaximumNetworkInterfaces,IPv4sPerENI:Ipv4AddressesPerInterface}'

# Max pods formula: (MaxENIs x (IPv4sPerENI - 1)) + 2
# m5.large: 3 ENIs x (10-1) + 2 = 29 pods

Security Groups for Pods

Som standard delar alla poddar på en nod nodens säkerhetsgrupp. Med funktionen Security Groups for Pods kan Ni tilldela individuella säkerhetsgrupper till specifika poddar med hjälp av den anpassade resursen SecurityGroupPolicy. Detta möjliggör detaljerad nätverksåtkomstkontroll — till exempel kan endast en databaspodd ta emot trafik på port 5432 från API-poddens säkerhetsgrupp. Funktionen kräver VPC CNI version 1.7.7 eller senare samt en trunk-ENI på noden.

# Define a SecurityGroupPolicy (custom resource)
apiVersion: vpcresources.k8s.aws/v1beta1
kind: SecurityGroupPolicy
metadata:
  name: db-pod-sg-policy
  namespace: production
spec:
  podSelector:
    matchLabels:
      role: database
  securityGroups:
    groupIds:
    - sg-0db1234567890abcd

Typer av Kubernetes-tjänster i EKS

Kubernetes-objekt av typen Services exponerar en uppsättning poddar under ett stabilt DNS-namn och en stabil IP-adress. I EKS är de tre relevanta tjänstetyperna: ClusterIP (endast intern kommunikation i klustret), NodePort (öppnar en port på varje nod — används sällan i EKS) och LoadBalancer (provisionerar automatiskt en AWS-lastbalanserare). Typen LoadBalancer är det vanligaste sättet att exponera EKS-tjänster mot internet.

# Expose a deployment with a LoadBalancer service
kubectl expose deployment my-api \
  --type=LoadBalancer \
  --name=my-api-svc \
  --port=80 \
  --target-port=8080

# Check the assigned AWS load balancer hostname
kubectl get svc my-api-svc -o wide

AWS Load Balancer Controller

AWS Load Balancer Controller är en Kubernetes-controller med öppen källkod som hanterar ALB- och NLB-resurser åt EKS-kluster. När Ni skapar ett Kubernetes-objekt av typen Ingress provisionerar controllern en Application Load Balancer. När Ni skapar en Service av typen LoadBalancer med rätt annoteringar provisionerar den en Network Load Balancer. Controllern ersätter den äldre inbyggda Kubernetes-leverantören för lastbalansering.

# Install AWS Load Balancer Controller with Helm
helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
  -n kube-system \
  --set clusterName=my-cluster \
  --set serviceAccount.create=false \
  --set serviceAccount.name=aws-load-balancer-controller \
  --set region=us-east-1 \
  --set vpcId=vpc-0abc1234def567890

Kubernetes Ingress med ALB

Ett Kubernetes-objekt av typen Ingress definierar HTTP/HTTPS-routningsregler — baserade på sökväg och värd — in i Ert kluster. AWS Load Balancer Controller läser Ingress-objekt som har annoteringen kubernetes.io/ingress.class: alb och skapar en motsvarande Application Load Balancer med matchande lyssnarregler. Detta eliminerar behovet av att manuellt skapa ALB:er och målgrupper för varje applikationstjänst.

# Ingress YAML that creates an ALB
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api-ingress
  namespace: production
  annotations:
    kubernetes.io/ingress.class: alb
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/target-type: ip
spec:
  rules:
  - http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-svc
            port:
              number: 80

NLB för TCP/UDP-arbetsbelastningar

När Er arbetsbelastning kräver TCP eller UDP (inte HTTP) — till exempel en spelserver, en gRPC-tjänst eller en databasserverproxy — ska Ni använda NLB i stället för ALB. Annotera Kubernetes-tjänsten med service.beta.kubernetes.io/aws-load-balancer-type: 'external' och service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: 'ip'. Controllern provisionerar en NLB med poddarnas IP-adresser som direkta mål, vilket kringgår portvidarebefordran på nodnivå och ger lägre latens.

# Service YAML that creates an NLB with IP targets
apiVersion: v1
kind: Service
metadata:
  name: grpc-svc
  namespace: production
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: 'external'
    service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: 'ip'
    service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing
spec:
  type: LoadBalancer
  selector:
    app: grpc-server
  ports:
  - port: 50051
    targetPort: 50051
    protocol: TCP

DNS-upplösning i klustret

EKS kör CoreDNS som DNS-leverantör för klustret. Varje tjänst får ett DNS-namn i formatet service-name.namespace.svc.cluster.local, som matchar tjänstens ClusterIP. Poddar kan också hittas via DNS. CoreDNS distribueras som en Deployment (inte ett DaemonSet), och antalet repliker bör skalas utifrån klustrets storlek. EKS hanterar CoreDNS som ett tillägg, vilket möjliggör automatiska versionsuppgraderingar.

# Verify DNS resolution from within a pod
kubectl run dns-test --image=busybox --rm -it --restart=Never -- \
  nslookup kubernetes.default.svc.cluster.local

# Expected output: Name: kubernetes.default.svc.cluster.local
# Address: 10.100.0.1 (ClusterIP of the kubernetes service)

Nätverkspolicyer i EKS

Kubernetes-objekt av typen NetworkPolicy definierar tillåtelseregler för trafik mellan poddar och från poddar till externa mål. Som standard kan alla poddar i ett kluster kommunicera fritt. För att införa zero trust-nätverk kan Ni installera Amazon VPC CNI network policy controller (tillgänglig sedan VPC CNI v1.14). Nätverkspolicyer utvärderas på Linux-kärnnivå med eBPF, vilket ger högpresterande tillämpning utan ett overlay-nätverk.

# NetworkPolicy: allow traffic to api pods only from frontend pods
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-allow-frontend
  namespace: production
spec:
  podSelector:
    matchLabels:
      role: api
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: frontend
    ports:
    - protocol: TCP
      port: 8080

Tips för felsökning av VPC CNI

Vanliga nätverksproblem i EKS är brist på IP-adresser (åtgärdas genom att aktivera prefixdelegering eller lägga till större subnät), poddar som fastnar i Pending eftersom noden saknar tillgängliga sekundära IP-adresser och intermittenta DNS-upplösningsfel som orsakas av för få CoreDNS-repliker. Använd kubectl describe pod för att kontrollera händelser, kubectl describe node för att se antalet allokerade IP-adresser och CloudWatch Container Insights för att övervaka DNS-felfrekvenser i klustret.

# Enable prefix delegation to increase pod density per node
kubectl set env daemonset aws-node \
  -n kube-system \
  ENABLE_PREFIX_DELEGATION=true \
  WARM_PREFIX_TARGET=1

# Check current IP usage on a node
kubectl describe node ip-10-0-1-100.ec2.internal | grep -A5 'Allocatable'

Snabbtest

Testa Er förståelse av AWS Solutions Architect-koncepten (SAA-C03) från den här lektionen.

Besvara frågan i den interaktiva lektionen

Sammanfattning av lektionen

I den här lektionen lärde Ni Er att: Amazon VPC CNI plugin tilldelar varje podd inbyggda VPC-IP-adresser för sömlös VPC-integration, AWS Load Balancer Controller provisionerar ALB:er för HTTP-Ingress och NLB:er för TCP/UDP-tjänster, och Security Groups for Pods möjliggör nätverksåtkomstkontroll på poddnivå. Nästa avsnitt handlar om IRSA för att koppla detaljerade IAM-roller till Kubernetes-tjänstekonton.

Gratis att börja

Lär dig Cloud & IT Cert Prep med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 150
Lektioner: 600

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”EKS-nätverk: VPC CNI och lastbalansering” gratis?

Ja – hela texten till ”EKS-nätverk: VPC CNI och lastbalansering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Cloud & IT Cert Prep, kan Ni uppgradera till CoddyKit PRO. Kursen i Cloud & IT Cert Prep innehåller totalt 4 lektioner.

Vad lär jag mig i ”EKS-nätverk: VPC CNI och lastbalansering”?

Använd plugin-programmet Amazon VPC CNI så att pods får inbyggda VPC-IP-adresser och exponera tjänster med AWS Load Balancer Controller. Ni övar på Cloud & IT Cert Prep med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Cloud & IT Cert Prep?

Du behöver inga förkunskaper. Utbildningen i Cloud & IT Cert Prep på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”EKS-nätverk: VPC CNI och lastbalansering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Cloud & IT Cert Prep-lektionen?

Ja. Varje Cloud & IT Cert Prep-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

EKS-kontrollplan och arbetarnoder
Fargate-profiler för serverlösa pods
EKS-nätverk: VPC CNI och lastbalansering
IAM-roller för tjänstekonton (IRSA)

← Tillbaka till Cloud & IT Cert Prep