Bereitstellen und Debuggen von Amazon EKS-Clustern

Erstellt von Svenja Raether (AWS) und Mathew George (AWS)

Umgebung: PoC oder Pilot	Technologien: Container und Mikroservices; Infrastruktur; Modernisierung; Serverlos; CloudNative	Arbeitslast: Alle anderen Workloads
AWS-Dienste: Amazon EKS; AWS Fargate

Übersicht

Container werden zu einem unverzichtbaren Bestandteil der Entwicklung cloudnativer Anwendungen. Kubernetes bietet eine effiziente Möglichkeit, Container zu verwalten und zu orchestrieren. Amazon Elastic Kubernetes Service (Amazon EKS) ist ein vollständig verwalteter, zertifizierter Kubernetes-konformer Service für den Aufbau, die Sicherung, den Betrieb und die Wartung von Kubernetes-Clustern auf Amazon Web Services (AWS). Es unterstützt die Ausführung von Pods auf AWS Fargate, um bedarfsgerecht dimensionierte Rechenkapazität bereitzustellen.

Für Entwickler und Administratoren ist es wichtig, die Debugging-Optionen für die Ausführung containerisierter Workloads zu kennen. Dieses Muster führt Sie durch die Bereitstellung und das Debuggen von Containern auf Amazon EKS mit AWS Fargate. Es umfasst das Erstellen, Bereitstellen, Zugreifen, Debuggen und Bereinigen der Amazon EKS-Workloads.

Voraussetzungen und Einschränkungen

Voraussetzungen

• Ein aktives AWS-Konto

• Die Rolle AWS Identity and Access Management (IAM) ist mit ausreichenden Berechtigungen konfiguriert, um Amazon EKS, IAM-Rollen und serviceverknüpfte Rollen zu erstellen und mit diesen zu interagieren

• Auf dem lokalen Computer installierte AWS-Befehlszeilenschnittstelle (AWS CLI)

• eksctl

• kubectl

• Helm

Einschränkungen

• Dieses Muster bietet Entwicklern nützliche Debugging-Methoden für Entwicklungsumgebungen. Es enthält keine bewährten Methoden für Produktionsumgebungen.

• Wenn Sie Windows ausführen, verwenden Sie Ihre betriebssystemspezifischen Befehle zum Einstellen der Umgebungsvariablen.

Verwendete Produktversionen

• AWS-CLI Version 2

• kubectl-Version innerhalb eines geringfügigen Versionsunterschieds der von Ihnen verwendeten Amazon EKS-Steuerebene

• eksctl neueste Version

• Helm v3

Architektur

Technologie-Stack

• Application Load Balancer

• Amazon EKS

• AWS Fargate

Zielarchitektur

Alle im Diagramm gezeigten Ressourcen werden mithilfe von kubectl Befehlen eksctl und Befehlen bereitgestellt, die von einem lokalen Computer aus ausgegeben werden. Private Cluster müssen von einer Instance aus ausgeführt werden, die sich innerhalb der privaten VPC befindet.

Die Zielarchitektur besteht aus einem EKS-Cluster, der den Fargate-Starttyp verwendet. Dadurch wird bedarfsgerecht dimensionierte Rechenkapazität bereitgestellt, ohne dass Servertypen angegeben werden müssen. Der EKS-Cluster verfügt über eine Steuerungsebene, die zur Verwaltung der Clusterknoten und Workloads verwendet wird. Die Pods werden in privaten VPC-Subnetzen bereitgestellt, die sich über mehrere Availability Zones erstrecken. Auf die Amazon ECR Public Gallery wird verwiesen, um ein NGINX-Webserver-Image abzurufen und für die Pods des Clusters bereitzustellen.

Das Diagramm zeigt, wie Sie mithilfe von kubectl Befehlen auf die Amazon EKS-Steuerebene zugreifen und wie Sie mithilfe des Application Load Balancer auf die Anwendung zugreifen.

.

1. Ein lokaler Computer außerhalb der AWS-Cloud sendet Befehle an die Kubernetes-Steuerebene innerhalb einer von Amazon EKS verwalteten VPC.

2. Amazon EKS plant Pods auf der Grundlage der Selektoren im Fargate-Profil.

3. Der lokale Computer öffnet die Application Load Balancer Balancer-URL im Browser.

4. Der Application Load Balancer verteilt den Datenverkehr zwischen den Kubernetes-Pods in Fargate-Clusterknoten, die in privaten Subnetzen bereitgestellt werden, die sich über mehrere Availability Zones erstrecken.

Tools

AWS-Services

• Amazon Elastic Container Registry (Amazon ECR) ist ein verwalteter Container-Image-Registry-Service, der sicher, skalierbar und zuverlässig ist.

• Amazon Elastic Kubernetes Service (Amazon EKS) hilft Ihnen, Kubernetes auf AWS auszuführen, ohne Ihre eigene Kubernetes-Steuerebene oder Knoten installieren oder verwalten zu müssen. Dieses Muster verwendet auch das Befehlszeilentool eksctl, um mit Kubernetes-Clustern auf Amazon EKS zu arbeiten.

• Mit AWS Fargate können Sie Container ausführen, ohne Server oder Amazon Elastic Compute Cloud (Amazon EC2) -Instances verwalten zu müssen. Es wird in Verbindung mit Amazon Elastic Container Service (Amazon ECS) verwendet.

• Elastic Load Balancing (ELB) verteilt eingehenden Anwendungs- oder Netzwerkverkehr auf mehrere Ziele. Sie können beispielsweise den Datenverkehr auf Amazon Elastic Compute Cloud (Amazon EC2) -Instances, Container und IP-Adressen in einer oder mehreren Availability Zones verteilen. Dieses Muster verwendet die AWS Load Balancer Controller-Kontrollkomponente, um den Application Load Balancer zu erstellen, wenn ein Kubernetes-Ingress bereitgestellt wird. Der Application Load Balancer verteilt den eingehenden Datenverkehr auf mehrere Ziele.

Andere Tools

• Helm ist ein Open-Source-Paketmanager für Kubernetes. In diesem Muster wird Helm verwendet, um den AWS Load Balancer Controller zu installieren.

• Kubernetes ist ein Open-Source-System zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen.

• NGINX ist ein leistungsstarker Web- und Reverse-Proxyserver.

Epen

Erstellen Sie einen EKS-Cluster

Aufgabe	Beschreibung	Erforderliche Fähigkeiten
Erstellen Sie die Dateien.	Erstellen Sie mithilfe des Codes im Abschnitt Zusätzliche Informationen die folgenden Dateien: clusterconfig-fargate.yaml nginx-deployment.yaml nginx-service.yaml nginx-ingress.yaml index.html	App-Entwickler, AWS-Administrator, AWS DevOps
Legen Sie Umgebungsvariablen fest.	Hinweis: Wenn ein Befehl aufgrund früherer unerledigter Aufgaben fehlschlägt, warten Sie einige Sekunden und führen Sie den Befehl dann erneut aus. Dieses Muster verwendet die AWS-Region und den Clusternamen, die in der Datei definiert sindclusterconfig-fargate.yaml. Legen Sie dieselben Werte wie Umgebungsvariablen fest, um in weiteren Befehlen auf sie zu verweisen. export AWS_REGION="us-east-1" export CLUSTER_NAME="my-fargate"	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Erstellen Sie einen EKS-Cluster.	Führen Sie den folgenden Befehl aus, um einen EKS-Cluster zu erstellen, der die Spezifikationen aus der clusterconfig-fargate.yaml Datei verwendet. eksctl create cluster -f clusterconfig-fargate.yaml Die Datei enthält dieClusterConfig, die einen neuen EKS-Cluster mit dem Namen my-fargate-cluster us-east-1 Region und ein Standard-Fargate-Profil (fp-default) bereitstellt. Das Fargate-Standardprofil ist mit zwei Selektoren (defaultundkube-system) konfiguriert.	App-Entwickler, AWS DevOps, AWS-Administrator
Überprüfen Sie den erstellten Cluster.	Führen Sie den folgenden Befehl aus, um den erstellten Cluster zu überprüfen. eksctl get cluster --output yaml Die Ausgabe sollte wie folgt aussehen. - Name: my-fargate Owned: "True" Region: us-east-1 Überprüfen Sie das erstellte Fargate-Profil mit demCLUSTER_NAME. eksctl get fargateprofile --cluster $CLUSTER_NAME --output yaml Dieser Befehl zeigt Informationen zu den Ressourcen an. Sie können die Informationen verwenden, um den erstellten Cluster zu überprüfen. Die Ausgabe sollte wie folgt aussehen. - name: fp-default podExecutionRoleARN: arn:aws:iam::<YOUR-ACCOUNT-ID>:role/eksctl-my-fargate-cluster-FargatePodExecutionRole-xxx selectors: - namespace: default - namespace: kube-system status: ACTIVE subnets: - subnet-aaa - subnet-bbb - subnet-ccc	App-Entwickler, AWS DevOps, AWS-Systemadministrator

Stellen Sie einen Container bereit

Aufgabe	Beschreibung	Erforderliche Fähigkeiten
Stellen Sie den NGINX-Webserver bereit.	Führen Sie den folgenden Befehl aus, um die NGINX-Webserver-Bereitstellung auf dem Cluster anzuwenden. kubectl apply -f ./nginx-deployment.yaml Die Ausgabe sollte wie folgt aussehen. deployment.apps/nginx-deployment created Die Bereitstellung umfasst drei Repliken des NGINX-Images aus der Amazon ECR Public Gallery. Das Image wird im Standard-Namespace bereitgestellt und auf Port 80 der laufenden Pods verfügbar gemacht.	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Überprüfen Sie die Bereitstellung und die Pods.	(Optional) Überprüfen Sie die Bereitstellung. Sie können den Status Ihrer Bereitstellung mit dem folgenden Befehl überprüfen. kubectl get deployment Die Ausgabe sollte wie folgt aussehen. NAME READY UP-TO-DATE AVAILABLE AGE nginx-deployment 3/3 3 3 7m14s Ein Pod ist ein bereitstellbares Objekt in Kubernetes, das einen oder mehrere Container enthält. Führen Sie den folgenden Befehl aus, um alle Pods aufzulisten.  kubectl get pods Die Ausgabe sollte wie folgt aussehen. NAME READY STATUS RESTARTS AGE nginx-deployment-xxxx-aaa 1/1 Running 0 94s nginx-deployment-xxxx-bbb 1/1 Running 0 94s nginx-deployment-xxxx-ccc 1/1 Running 0 94s	App-Entwickler, AWS DevOps, AWS-Administrator
Skalieren Sie die Bereitstellung.	Verwenden Sie den folgenden Befehl, um die Bereitstellung von den drei angegebenen Replikaten deployment.yaml auf vier Replikate zu skalieren.  kubectl scale deployment nginx-deployment --replicas 4 Die Ausgabe sollte wie folgt aussehen. deployment.apps/nginx-deployment scaled	App-Entwickler, AWS DevOps, AWS-Systemadministrator

Stellen Sie einen AWS Load Balancer Controller bereit

Aufgabe	Beschreibung	Erforderliche Fähigkeiten
Legen Sie Umgebungsvariablen fest.	Beschreiben Sie den CloudFormation Stack des Clusters, um Informationen über seine VPC abzurufen. aws cloudformation describe-stacks --stack-name eksctl-$CLUSTER_NAME-cluster --query "Stacks[0].Outputs[?OutputKey==\`VPC\`].OutputValue" Die Ausgabe sollte wie folgt aussehen. [ "vpc-<YOUR-VPC-ID>" ] Kopieren Sie die VPC-ID und exportieren Sie sie als Umgebungsvariable. export VPC_ID="vpc-<YOUR-VPC-ID>"	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Konfigurieren Sie IAM für das Cluster-Servicekonto.	Verwenden Sie das AWS_REGION und CLUSTER_NAME aus dem früheren Epic, um einen IAM Open ID Connect-Anbieter für den Cluster zu erstellen. eksctl utils associate-iam-oidc-provider \ --region $AWS_REGION \ --cluster $CLUSTER_NAME \ --approve	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Laden Sie die IAM-Richtlinie herunter und erstellen Sie sie.	Laden Sie die IAM-Richtlinie für den AWS Load Balancer Controller herunter, mit der dieser in Ihrem Namen AWS-APIs aufrufen kann. curl -o iam-policy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/main/docs/install/iam_policy.json Erstellen Sie die Richtlinie in Ihrem AWS-Konto mithilfe der AWS-CLI. aws iam create-policy \ --policy-name AWSLoadBalancerControllerIAMPolicy \ --policy-document file://iam-policy.json Die Ausgabe sollte folgendermaßen aussehen. { "Policy": { "PolicyName": "AWSLoadBalancerControllerIAMPolicy", "PolicyId": "<YOUR_POLICY_ID>", "Arn": "arn:aws:iam::<YOUR-ACCOUNT-ID>:policy/AWSLoadBalancerControllerIAMPolicy", "Path": "/", "DefaultVersionId": "v1", "AttachmentCount": 0, "PermissionsBoundaryUsageCount": 0, "IsAttachable": true, "CreateDate": "<YOUR-DATE>", "UpdateDate": "<YOUR-DATE>" } } Speichern Sie den Amazon-Ressourcennamen (ARN) der Richtlinie unter$POLICY_ARN. export POLICY_ARN=”arn:aws:iam::<YOUR-ACCOUNT-ID>:policy/AWSLoadBalancerControllerIAMPolicy”	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Erstellen Sie ein IAM-Servicekonto.	Erstellen Sie ein aws-load-balancer-controller im Namespace benanntes IAM-Dienstkonto. kube-system Verwenden Sie dieCLUSTER_NAME, undAWS_REGION, POLICY_ARN die Sie zuvor konfiguriert haben. eksctl create iamserviceaccount \ --cluster=$CLUSTER_NAME \ --region=$AWS_REGION \ --attach-policy-arn=$POLICY_ARN \ --namespace=kube-system \ --name=aws-load-balancer-controller \ --override-existing-serviceaccounts \ --approve Überprüfen Sie die Erstellung. eksctl get iamserviceaccount \ --cluster $CLUSTER_NAME \ --name aws-load-balancer-controller \ --namespace kube-system \ --output yaml Die Ausgabe sollte wie folgt aussehen. - metadata: name: aws-load-balancer-controller namespace: kube-system status: roleARN: arn:aws:iam::<YOUR-ACCOUNT-ID>:role/eksctl-my-fargate-addon-iamserviceaccount-ku-Role1-<YOUR-ROLE-ID> wellKnownPolicies: autoScaler: false awsLoadBalancerController: false certManager: false ebsCSIController: false efsCSIController: false externalDNS: false imageBuilder: false	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Installieren Sie den AWS Load Balancer Controller.	Aktualisieren Sie das Helm-Repository. helm repo update Fügen Sie das Amazon EKS-Chart-Repository zum Helm-Repo hinzu.  helm repo add eks https://aws.github.io/eks-charts Wenden Sie die benutzerdefinierten Kubernetes-Ressourcendefinitionen (CRDs) an, die vom AWS Load Balancer Controller eks-chart im Hintergrund verwendet werden. kubectl apply -k "github.com/aws/eks-charts/stable/aws-load-balancer-controller//crds?ref=master" Die Ausgabe sollte wie folgt aussehen. customresourcedefinition.apiextensions.k8s.io/ingressclassparams.elbv2.k8s.aws created customresourcedefinition.apiextensions.k8s.io/targetgroupbindings.elbv2.k8s.aws created Installieren Sie das Helm-Diagramm mithilfe der Umgebungsvariablen, die Sie zuvor festgelegt haben. helm install aws-load-balancer-controller eks/aws-load-balancer-controller \ --set clusterName=$CLUSTER_NAME \ --set serviceAccount.create=false \ --set region=$AWS_REGION \ --set vpcId=$VPC_ID \ --set serviceAccount.name=aws-load-balancer-controller \ -n kube-system Die Ausgabe sollte wie folgt aussehen. NAME: aws-load-balancer-controller LAST DEPLOYED: <YOUR-DATE> NAMESPACE: kube-system STATUS: deployed REVISION: 1 TEST SUITE: None NOTES: AWS Load Balancer controller installed!	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Erstellen Sie einen NGINX-Service.	Erstellen Sie einen Dienst, um die NGINX-Pods mithilfe der Datei verfügbar zu machen. nginx-service.yaml kubectl apply -f nginx-service.yaml Die Ausgabe sollte wie folgt aussehen. service/nginx-service created	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Erstellen Sie die Kubernetes-Ingress-Ressource.	Erstellen Sie einen Dienst, um den Kubernetes-NGINX-Ingress mithilfe der Datei verfügbar zu machen. nginx-ingress.yaml kubectl apply -f nginx-ingress.yaml Die Ausgabe sollte wie folgt aussehen. ingress.networking.k8s.io/nginx-ingress created	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Rufen Sie die Load Balancer-URL ab.	Verwenden Sie den folgenden Befehl, um die Eingangsinformationen abzurufen. kubectl get ingress nginx-ingress Die Ausgabe sollte wie folgt aussehen. NAME CLASS HOSTS ADDRESS PORTS AGE nginx-ingress <none> * k8s-default-nginxing-xxx.us-east-1.elb.amazonaws.com 80 80s Kopieren Sie das ADDRESS (zum Beispielk8s-default-nginxing-xxx.us-east-1.elb.amazonaws.com) aus der Ausgabe und fügen Sie es in Ihren Browser ein, um auf die index.html Datei zuzugreifen.	App-Entwickler, AWS DevOps, AWS-Systemadministrator

Debuggen Sie laufende Container

Aufgabe	Beschreibung	Erforderliche Fähigkeiten
Wählen Sie einen Pod aus.	Listet alle Pods auf und kopiert den Namen des gewünschten Pods.  kubectl get pods Die Ausgabe sollte wie folgt aussehen. NAME READY STATUS RESTARTS AGE nginx-deployment-xxxx-aaa 1/1 Running 0 55m nginx-deployment-xxxx-bbb 1/1 Running 0 55m nginx-deployment-xxxx-ccc 1/1 Running 0 55m nginx-deployment-xxxx-ddd 1/1 Running 0 42m Dieser Befehl listet die vorhandenen Pods und zusätzliche Informationen auf. Wenn Sie an einem bestimmten Pod interessiert sind, geben Sie den Namen des Pods, an dem Sie interessiert sind, für die POD_NAME Variable ein oder legen Sie ihn als Umgebungsvariable fest. Andernfalls lassen Sie diesen Parameter weg, um nach allen Ressourcen zu suchen. export POD_NAME="nginx-deployment-<YOUR-POD-NAME>"	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Greifen Sie auf die Protokolle zu.	Rufen Sie die Protokolle von dem Pod ab, den Sie debuggen möchten. kubectl logs $POD_NAME	App-Entwickler, AWS-Systemadministrator, AWS DevOps
Leiten Sie den NGINX-Port weiter.	Verwenden Sie Port-Forwarding, um den Port des Pods für den Zugriff auf den NGINX-Webserver einem Port auf Ihrem lokalen Computer zuzuordnen. kubectl port-forward deployment/nginx-deployment 8080:80 Öffnen Sie in Ihrem Browser die folgende URL. http://localhost:8080 Der port-forward Befehl ermöglicht den Zugriff auf die index.html Datei, ohne sie über einen Load Balancer öffentlich verfügbar zu machen. Dies ist nützlich, um beim Debuggen auf die laufende Anwendung zuzugreifen. Sie können die Portweiterleitung beenden, indem Sie den Tastaturbefehl Strg+C drücken.	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Befehle innerhalb des Pods ausführen.	Verwenden Sie den folgenden Befehl, um sich die aktuelle index.html Datei anzusehen.  kubectl exec $POD_NAME -- cat /usr/share/nginx/html/index.html Sie können den exec Befehl verwenden, um jeden Befehl direkt im Pod auszuführen. Dies ist nützlich für das Debuggen laufender Anwendungen.	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Dateien in einen Pod kopieren.	Entfernen Sie die index.html Standarddatei auf diesem Pod. kubectl exec $POD_NAME -- rm /usr/share/nginx/html/index.html Laden Sie die benutzerdefinierte lokale Datei index.html auf den Pod hoch. kubectl cp index.html $POD_NAME:/usr/share/nginx/html/ Sie können den cp Befehl verwenden, um Dateien direkt zu einem der Pods zu ändern oder hinzuzufügen.	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Verwenden Sie Port-Forwarding, um die Änderung anzuzeigen.	Verwenden Sie die Portweiterleitung, um die Änderungen zu überprüfen, die Sie an diesem Pod vorgenommen haben. kubectl port-forward pod/$POD_NAME 8080:80 Öffnen Sie die folgende URL in Ihrem Browser. http://localhost:8080 Die an der index.html Datei vorgenommenen Änderungen sollten im Browser sichtbar sein.	App-Entwickler, AWS DevOps, AWS-Systemadministrator

Löschen von Ressourcen

Aufgabe	Beschreibung	Erforderliche Fähigkeiten
Löschen Sie den Load Balancer.	Löschen Sie den Ingress. kubectl delete ingress/nginx-ingress Die Ausgabe sollte wie folgt aussehen. ingress.networking.k8s.io "nginx-ingress" deleted Löschen Sie den Service: kubectl delete service/nginx-service Die Ausgabe sollte wie folgt aussehen. service "nginx-service" deleted Löschen Sie den Load Balancer-Controller. helm delete aws-load-balancer-controller -n kube-system Die Ausgabe sollte wie folgt aussehen. release "aws-load-balancer-controller" uninstalled Löschen Sie das Dienstkonto. eksctl delete iamserviceaccount --cluster $CLUSTER_NAME --namespace kube-system --name aws-load-balancer-controller	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Löschen Sie die Bereitstellung.	Verwenden Sie den folgenden Befehl, um die Bereitstellungsressourcen zu löschen. kubectl delete deploy/nginx-deployment Die Ausgabe sollte wie folgt aussehen. deployment.apps "nginx-deployment" deleted	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Löschen Sie den Cluster.	Löschen Sie den EKS-Cluster mithilfe des folgenden Befehls, wobei der Clustername my-fargate steht. eksctl delete cluster --name $CLUSTER_NAME Mit diesem Befehl wird der gesamte Cluster einschließlich aller zugehörigen Ressourcen gelöscht.	App-Entwickler, AWS DevOps, AWS-Systemadministrator
Löschen Sie die IAM-Richtlinie.	Löschen Sie die zuvor erstellte Richtlinie mithilfe der AWS-CLI. aws iam delete-policy --policy-arn $POLICY_ARN	App-Entwickler, AWS-Administrator, AWS DevOps

Fehlerbehebung

Problem

Lösung

Sie erhalten bei der Clustererstellung eine Fehlermeldung, die besagt, dass Ihre Ziel-Availability Zone nicht über genügend Kapazität verfügt, um den Cluster zu unterstützen. Sie sollten eine Meldung ähnlich der folgenden sehen. Cannot create cluster 'my-fargate' because us-east-1e, the targeted availability zone, does not currently have sufficient capacity to support the cluster. Retry and choose from these availability zones: us-east-1a, us-east-1b, us-east-1c, us-east-1d, us-east-1f

Erstellen Sie den Cluster erneut und verwenden Sie dabei die in der Fehlermeldung empfohlenen Availability Zones. Geben Sie in der letzten Zeile Ihrer clusterconfig-fargate.yaml Datei eine Liste von Availability Zones an (z. B.availabilityZones: ["us-east-1a", "us-east-1b", "us-east-1c"]).

Zugehörige Ressourcen

• Amazon EKS-Dokumentation

• Lastenausgleich für Anwendungen auf Amazon EKS

• Leitfäden zu bewährten Methoden von EKS

• Dokumentation zum AWS Load Balancer Controller

• eksctl-Dokumentation

• NGINX-Bild der öffentlichen Galerie von Amazon ECR

• Helm-Dokumentation

• Running Pods debuggen (Kubernetes-Dokumentation)

• Amazon EKS-Werkstatt

• Fehler bei der Erstellung des EKS-Clusters

Zusätzliche Informationen

clusterconfig-fargate.yaml

apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: my-fargate
  region: us-east-1

fargateProfiles:
  - name: fp-default
    selectors:
      - namespace: default
      - namespace: kube-system

nginx-bereitstellung.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: "nginx-deployment"
  namespace: "default"
spec:
  replicas: 3
  selector:
    matchLabels:
      app: "nginx"
  template:
    metadata:
      labels:
        app: "nginx"
    spec:
      containers:
      - name: nginx
        image: public.ecr.aws/nginx/nginx:latest  
        ports:
        - containerPort: 80

nginx-service.yaml

apiVersion: v1
kind: Service
metadata:
  annotations:
    alb.ingress.kubernetes.io/target-type: ip
  name: "nginx-service"
  namespace: "default"
spec:
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
  type: NodePort
  selector:
    app: "nginx"

nginx-ingress.yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  namespace: "default"
  name:  "nginx-ingress"
  annotations:
    kubernetes.io/ingress.class: alb
    alb.ingress.kubernetes.io/scheme: internet-facing
spec:
  rules:
    - http:
        paths:
        - path: /
          pathType: Prefix
          backend:
            service:
              name: "nginx-service"
              port:
                number: 80

index.html

<!DOCTYPE html>
<html>

<body>
    <h1>Welcome to your customized nginx!</h1>
    <p>You modified the file on this running pod</p>
</body>

</html>