Informationen zum Provisioning eines ARM Kubernetes-Clusters auf OCI und zum Bereitstellen einer Nginx-Website

Sie können ein ARM-Kubernetes-Cluster auf OCI bereitstellen und dann eine Nginx-Website manuell oder automatisch mit einem Terraform-Skript bereitstellen. Nach dem Deployment kann die Website einfach in Ihrem lokalen Browser gestartet werden.

OKE-Cluster mit ARM-Pool manuell bereitstellen

Sie können ganz einfach ein Kubernetes-Cluster bereitstellen, eine Reihe heterogener Pools auf OCI erstellen und dann eine Nginx-Website über die OCI-Konsole bereitstellen. Dieser Ansatz ist hilfreich, wenn Sie nicht mit der Infrastrukturautomatisierung vertraut sind und stattdessen die Konsole verwenden möchten.

Gehen Sie in der OCI-Konsole wie folgt vor:

Stellen Sie zunächst das OKE-Cluster bereit:
1. Wählen Sie im Abschnitt "Entwicklerservices" die Option Kubernetes-Cluster (OKE) aus.
  Die Seite "Cluster erstellen" wird angezeigt.
2. Wählen Sie Schnellerstellung aus, um die erforderliche Kubernetes-Clusterinfrastruktur schnell und sicher bereitzustellen.
  Die Seite "Schnellerstellung" wird angezeigt.
3. Wählen Sie die ARM-Ausprägung (VM.Standard.A1.Flex) für Ihre Worker-Knoten aus. Mit dieser Ausprägung können Sie sowohl die Anzahl der OCPUs als auch die Menge des zugewiesenen Speichers konfigurieren, sodass Sie die Ressourcen (und den Preis entsprechend) an Ihre spezifischen Anforderungen anpassen können.
  
  Hinweis:
  Wenn Sie dieses Cluster für eine High Availability-(HA-)Website erstellen, halten Sie die Ressourcen auf ein Minimum. Bei Bedarf können Sie die Anzahl der Knoten später vertikal skalieren.
4. Nachdem das Cluster bereitgestellt wurde, können Sie zusätzliche Pools mit Spezialrechner hinzufügen, die Sie wiederum an bestimmte Images in der Deployment-Datei binden können. Beispiel: Sie können einen Pool mit GPU-backed-Knoten für die von der Website ausgeführten ML-Aufgaben einrichten (z.B. Inhaltsempfehlung oder ein Backend zur Gesichtserkennung).
  Um zusätzliche Knotenpools hinzuzufügen, aktualisieren Sie einfach die Ausprägung des Abschnitts "Knotenpool" auf der Seite "Clusterdetails":
  1. Gehen Sie zum Menü "Ressourcen".
  2. Klicken Sie auf Knotenpools und dann auf Neuen Pool hinzufügen.
  3. Ändern Sie den Pool nach Bedarf, indem Sie die Knotenausprägungen hinzufügen/ändern.
Verwenden Sie jetzt eine Deployment-Datei, um auf das Cluster zuzugreifen und mit dem Deployment der Nginx-Umgebung zu beginnen:
1. Navigieren Sie zu Ihrem Cluster, und klicken Sie auf Auf Cluster zugreifen.
  Der Schnellzugriffsbildschirm wird angezeigt. Führen Sie die Schritte 1 und 2 (wie auf dem Bildschirm angegeben) aus, um fortzufahren. Wenn Sie den cloud shell-Zugriff verwenden, müssen Sie die kubectl-Umgebung nicht auf Ihrem Rechner einrichten und konfigurieren. Dieser Prozess startet einen Webterminalemulator und konfiguriert ihn für Ihre Umgebung. Wie in Schritt 2 auf dem Bildschirm beschrieben, wird beim Einfügen des dort angegebenen OCI-CLI-Befehls kubectl für den Zugriff auf Ihr brandneues Cluster konfiguriert.
2. Prüfen Sie anschließend, ob die Pods durch Provisioning bereitgestellt wurden. Geben Sie Folgendes ein:
  
  Hinweis:
  Der Einfachheit halber können Sie mit allen Befehlen in diesem Playbook im Beispiel auf Kopieren klicken und den Befehl direkt an der Eingabeaufforderung einfügen.
```
kubectl get nodes -o wide
```
  Die beiden Knoten und eine Rechnerausprägung sollten angezeigt werden, die angeben, dass sie auf ARM ausgeführt werden. Beispiel:
```
NAME        STATUS ROLES AGE     VERSION   INTERNAL-IP   EXTERNAL-IP   OS-IMAGE              KERNEL-VERSION                   CONTAINER-RUNTIME 
10.0.10.129 Ready  node  3m57s   v.1.19.7  10.0.10.129   <none>        Oracle Linux Server   7.9 5.4.17-2102.el7uek.aarch64   docker://19.3.11 
10.0.10.153 Ready  node  3m17s   v.1.19.7  10.0.10.153   <none>        Oracle Linux Server   7.9 5.4.17-2102.el7uek.aarch64   docker://19.3.11
```
  Wenn Sie die Anzahl der Knoten vertikal skalieren müssen, klicken Sie auf dem Bildschirm "Knotenpool" auf Skalieren, und geben Sie unter Anzahl Knoten die erforderliche Anzahl von Knoten ein. OCI wird gestartet und für Sie angemeldet.

Stellen Sie schließlich die Nginx-Website bereit, und stellen Sie sie über einen Load Balancer bereit:

Stellen Sie ein Nginx-Deployment mit 2 Replikaten bereit, wobei der Service auf Port 80 horcht. Geben Sie Folgendes ein:
```
 kubectl apply -f https://k8s.io/examples/application/deployment.yaml 
```

Prüfen Sie das Deployment. Geben Sie Folgendes ein:

kubectl describe deployment nginx-deployment

Die Ausgabe sollte in etwa wie folgt angezeigt werden:

----
kubectl describe deployment nginx-deployment

Name:                   nginx-deployment
Namespace:              default
CreationTimestamp:      Tue, 03 Jan 2023 17:41:27 +0000
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=nginx
Replicas:               2 desired | 2 updated | 2 total | 2 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=nginx
  Containers:
   nginx:
    Image:        nginx:1.14.2
    Port:         80/TCP
    Host Port:    0/TCP
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  <none>
NewReplicaSet:   nginx-deployment-6595874d85 (2/2 replicas created)
Events:
  Type    Reason             Age   From                   Message
  ----    ------             ----  ----                   -------
  Normal  ScalingReplicaSet  15s   deployment-controller  Scaled up replica set nginx-deployment-6595874d85 to 2

----

Machen Sie den Service über einen Load Balancer für das Internet verfügbar. Geben Sie Folgendes ein:
```
kubectl expose deployment nginx-deployment --type=LoadBalancer --name=my-service 
```

Prüfen Sie, ob der Load Balancer über eine öffentliche IP verfügt. Geben Sie Folgendes ein:

kubectl get services

OCI startet den Load Balancer und weist die öffentliche IP zu. Nach kurzer Zeit sollte die folgende Ausgabe angezeigt werden:

NAME        TYPE          CLUSTER-IP     EXTERNAL-IP    PORT(S)              AGE 
kubernetes  ClusterIP     10.96.0.1      <none>         443/TCP, 12250/TCP   16m 
nginx-lb    LoadBalancer  10.96.224.64   138.2.218.135  80:30343/TCP         3m1s

OKE-Cluster mit ARM-Pool mit Ampere bereitstellen A1

Sie können das OKE-Cluster automatisch mit einem ARM-Pool bereitstellen und dann eine Nginx-Website mit einem Terraform-Skript bereitstellen, das auf GitHub bereitgestellt wird. Das Skript stellt ein Cluster mit zwei Knoten (in derselben Availability-Domain) auf zwei OCPUs bereit. Im Konfigurationsschritt wird dargestellt, wie die Anzahl der Knoten und OCPUs geändert wird. Das Skript stellt dann Nginx (2 Pods) bereit und stellt es hinter einem Load Balancer bereit.

So stellen Sie das Cluster bereit und stellen eine Website bereit:

Zunächst müssen Sie das Cluster konfigurieren.

Stellen Sie sicher, dass Sie einen OCI-Mandanten mit einem OCI-Compartment haben.

Melden Sie sich bei der OCI-Konsole an, öffnen Sie eine Befehlsshell, und führen Sie die folgenden Befehle aus:

git clone https://github.com/badr42/OKE_A1
cd OKE_A1
export TF_VAR_tenancy_ocid='tenancy-ocid'
export TF_VAR_compartment_ocid='comparment-ocid'
export TF_VAR_region='home-region'
<optional>
### Select Availability Domain, zero based, if not set it defaults to 0, 
### this allows you to select an AD that has available A1 chips
export TF_VAR_AD_number='0'

### Select number of nodes
export TF_VAR_node_count='2'

### Set OCPU count per node
export TF_VAR_ocpu_count='2'

Verwenden Sie Ihre spezifischen Werte für tenancy-ocid, comparment-ocid und home-region.

Erstellen Sie das Cluster. Geben Sie Folgendes ein:
```
terraform init
terraform plan
terraform apply
```
Nachdem Sie terraform apply ausgeführt haben, lassen Sie den Servicestart etwa 25 Minuten zu.

Starten Sie nach dem Starten des Service den Nginx-Load Balancer. Geben Sie Folgendes ein:

kubectl --kubeconfig kubeconfig get service

Die Systemausgabe sollte in etwa wie folgt aussehen:

NAME        TYPE           CLUSTER-IP      EXTERNAL-IP      PORT(S)              AGE
kubernetes  ClusterIP      10.96.0.1       <none>           443/TCP, 12250/TCP   16m
nginx-lb    LoadBalancer   10.96.224.64    138.2.218.135    80:30343/TCP       3m1s

Wenn Sie mit dem Deployment fertig sind, beenden Sie die Umgebung. Geben Sie Folgendes ein:
```
terraform destroy
```

Deployment testen

Um Ihre Bereitstellung zu testen, öffnen Sie einen Webbrowser und geben die öffentliche IP-Adresse in die Adressleiste ein. Wenn Sie die Webseite erfolgreich bereitgestellt haben, sollten Sie in der Lage sein, auf die neue Begrüßungsseite des Nginx-Servers zuzugreifen.