Hinweis:

Dieses Tutorial ist in einer von Oracle bereitgestellten kostenlosen Übungsumgebung verfügbar.
Es verwendet Beispielwerte für Oracle Cloud Infrastructure-Zugangsdaten, -Mandanten und -Compartments. Ersetzen Sie diese Werte durch die für Ihre Cloud-Umgebung spezifischen Werte.

Ausführen von Kubernetes auf Oracle Linux

Einführung

Kubernetes ist Griechisch für Pilot oder Helmsman - also die Person, die Befehle folgt und ein Schiff zu seinem ultimativen Ziel führt (und nicht der Kapitän, der Befehle gibt). Zu diesem Zweck ist Kubernetes eine Open-Source-Plattform, auf der Sie containerisierte Anwendungen bereitstellen, verwalten und skalieren können. Dies wird mit mehreren Befehlszeilen-Tools erreicht. In dieser Übung wird eines der Attribute kubectl zusammen mit YAML-Dateien verwendet, um die erforderlichen Attribute für die Organisation zu definieren, die die Anwendung bereitstellt. Außerdem wird erläutert, wie die Anwendung nach dem Deployment eingerichtet und verwaltet wird.

Alle Deployments in einem Kubernetes-Cluster werden als Objekte dargestellt. Diese bereitgestellten Objekte verwenden textbasierte YAML-Dateien, um Details zum erforderlichen Status jeder Anwendung anzugeben, die im Cluster bereitgestellt ist. Diese YAML-Dateien können Folgendes beschreiben:

Welche containerisierten Anwendungen auf welchen Knoten ausgeführt werden sollen
Details der für die Anwendung erforderlichen Ressourcen
Policys, die beschreiben, wie diese Anwendungen ihren Status beibehalten, wie Neustart-Policys, Upgrade-Policys usw.

Dieser dritte Punkt, obwohl wichtig, ist kompliziert, ohne die Grundlagen zu verstehen. Daher halten wir uns für den Moment bereit und behandeln dieses Thema in zukünftigen Tutorials.

Dieses Tutorial funktioniert mit Kubernetes in einer kompakten Oracle Cloud Native Environment auf Oracle Linux. Die Absicht ist nicht, ein "One-Stop-Shop" für alles zu sein, was für die Verwaltung eines Produktions-Deployments erforderlich ist. Stattdessen werden die erforderlichen Qualifikationen für das Deployment einer Beispielanwendung vorgestellt.

Ziele

Verschiedene Kubernetes-Komponenten wie Pod, Deployment und Service untersuchen
Verschiedene Kubernetes-Objekte untersuchen
Beispielprojekt bereitstellen und testen

Voraussetzungen

Ein Oracle Linux 8- oder höher-System mit der folgenden Konfiguration:

ein Nicht-Root-Benutzer mit sudo-Berechtigungen
Oracle Cloud Native Environment installiert und konfiguriert

Laborumgebung einrichten

Hinweis: Wenn Sie die kostenlose Übungsumgebung verwenden, finden Sie unter Oracle Linux Lab - Grundlagen Informationen zu Verbindungen und anderen Nutzungsanweisungen.

Informationen: Die kostenlose Übungsumgebung stellt Oracle Cloud Native Environment auf dem angegebenen Knoten bereit, der für das Erstellen von Umgebungen bereit ist. Dieses Deployment dauert nach dem Start etwa 8-10 Minuten. Aus diesem Grund sollten Sie die Übung schrittweise beenden und dann wieder abschließen.

Wenn noch nicht geschehen, öffnen Sie ein Terminal und verbinden Sie sich über SSH mit dem System ocne-node01.
```
ssh oracle@<ip_address_of_ol_node>
```

Prüfen Sie, ob die Umgebung bereit ist.

kubectl get pods -A

Beispielausgabe:

[oracle@ocne-node01 ~]$ kubectl get pods -A
NAMESPACE                      NAME                                             READY   STATUS    RESTARTS   AGE
externalip-validation-system   externalip-validation-webhook-7988bff847-8ws2v   1/1     Running   0          3m18s
kube-system                    coredns-7cbc77dbc7-qxqth                         1/1     Running   0          3m18s
kube-system                    coredns-7cbc77dbc7-r9bgj                         1/1     Running   0          3m18s
kube-system                    etcd-ocne-node01                                 1/1     Running   0          3m37s
kube-system                    kube-apiserver-ocne-node01                       1/1     Running   0          3m37s
kube-system                    kube-controller-manager-ocne-node01              1/1     Running   0          3m37s
kube-system                    kube-flannel-ds-vcwzn                            1/1     Running   0          3m18s
kube-system                    kube-proxy-7lx59                                 1/1     Running   0          3m18s
kube-system                    kube-scheduler-ocne-node01                       1/1     Running   0          3m37s
kubernetes-dashboard           kubernetes-dashboard-5d5d4947b5-7pffh            1/1     Running   0          3m18s

Deployment auf einem Pod und Anforderungsdetails erstellen

In Kubernetes ist Deployment ein technischer Begriff, der auf eine Datei verweist, die das Verhalten und die Eigenschaften eines Pods regelt. Administratoren weisen die Anwendung anhand von Deployments an, was zu tun ist, und Kubernetes führt die Aufgabe aus, diesen Status zu erreichen.

Die Beispiele verwenden ein Bild, das einen kleinen nginx-Webserver enthält, der die Quell-IP der Anforderungen, die er über einen HTTP-Header empfängt, zurückgibt.

Erstellen Sie ein Deployment von echoserver.

kubectl create deployment test --image=k8s.gcr.io/echoserver:1.4

Listen Sie alle Pods im Cluster auf.

kubectl get pods

Beispielausgabe:

[oracle@ocne-node01 ~]$ kubectl get pods
NAME                    READY   STATUS    RESTARTS   AGE
test-6c486b6d76-467p7   1/1     Running   0          53s

Hinweis: Der Podname enthält einen Suffixwert, der bei jedem Deployment des Pods unterschiedlich ist.

Verwenden Sie JSONPath, um den Podnamen einer Variablen zuzuweisen.

TESTPOD=$(kubectl get pods -o jsonpath='{ $.items[*].metadata.name }')

Testen Sie die Variablenzuweisung.

Mit dem Befehl kubectl get pods können Sie auch einen Podnamen als Parameter übergeben, um nur die Informationen für diesen Pod anzuzeigen.
```
kubectl get pods $TESTPOD
```

Fordern Sie ausgewählte Informationen zum Pod an.

kubectl get pod $TESTPOD --output custom-columns=NAME:metadata.name,NODE_IP:status.hostIP,POD_IP:status.podIP

Beispielausgabe:

[oracle@ocne-node01 ~]$ kubectl get pod $TESTPOD --output custom-columns=NAME:metadata.name,NODE_IP:status.hostIP,POD_IP:status.podIP
NAME                    NODE_IP      POD_IP
test-6c486b6d76-467p7   10.0.0.140   10.244.0.7

Rufen Sie die Poddetails ab.

kubectl describe pod $TESTPOD

Beispielausgabe:

[oracle@ocne-node01 ~]$ kubectl describe pod test-6c486b6d76-467p7
Name:         test-6c486b6d76-467p7
Namespace:    default
Priority:     0
Node:         ocne-node01/10.0.0.140
Start Time:   Tue, 28 Jun 2022 19:21:27 +0000
Labels:       app=test
              pod-template-hash=6c486b6d76
Annotations:  <none>
Status:       Running
IP:           10.244.0.7
IPs:
  IP:           10.244.0.7
Controlled By:  ReplicaSet/test-6c486b6d76
Containers:
  echoserver:
    Container ID:   cri-o://5b7866a27722ec0998cd9fe74945fb82b4dd9ed4c5c80671d9e8aa239c7008a4
    Image:          k8s.gcr.io/echoserver:1.4
    Image ID:       k8s.gcr.io/echoserver@sha256:5d99aa1120524c801bc8c1a7077e8f5ec122ba16b6dda1a5d3826057f67b9bcb
    Port:           <none>
    Host Port:      <none>
    State:          Running
      Started:      Tue, 28 Jun 2022 19:21:30 +0000
    Ready:          True
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-d67ph (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  kube-api-access-d67ph:
    Type:                    Projected (a volume that contains injected data from multiple sources)
    TokenExpirationSeconds:  3607
    ConfigMapName:           kube-root-ca.crt
    ConfigMapOptional:       <nil>
    DownwardAPI:             true
QoS Class:                   BestEffort
Node-Selectors:              <none>
Tolerations:                 node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                             node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:
  Type    Reason     Age   From               Message
  ----    ------     ----  ----               -------
  Normal  Scheduled  21m   default-scheduler  Successfully assigned default/test-6c486b6d76-467p7 to ocne-node01
  Normal  Pulling    21m   kubelet            Pulling image "k8s.gcr.io/echoserver:1.4"
  Normal  Pulled     21m   kubelet            Successfully pulled image "k8s.gcr.io/echoserver:1.4" in 3.102843235s
  Normal  Created    21m   kubelet            Created container echoserver
  Normal  Started    21m   kubelet            Started container echoserver

Deployment mit einer YAML-Datei erstellen

Mit Kubernetes-Deployment-Manifesten wird definiert, wie Sie eine Anwendung im Kubernetes-Cluster bereitstellen und Zugriff auf andere Kubernetes-Funktionen wie Self-Healing, Skalierbarkeit, Versionierung und Rolling-Updates ermöglichen. Diese Übung behandelt diese komplexere Funktionalität in Kubernetes nicht. Stattdessen wird dargestellt, wie eine Anwendung mit einer sehr einfachen Manifestdatei bereitgestellt wird.

Eine Deployment-Manifestdatei wird entweder in JSON oder YAML geschrieben. Die Verwendung von JSON ist zwar möglich, aber YAML ist aufgrund seiner Flexibilität, Lesbarkeit und der Möglichkeit, beschreibende Kommentare zum besseren Verständnis von Aspekten des endgültigen Deployments aufzunehmen, weitaus beliebter.

Bei der Ausführung eines Deployments wird ein Pod über eine Reihe deklarativer Updates aktualisiert, um den gewünschten Status für die ausgeführte Anwendung zu erreichen.

Während alle Details in deployment.yaml für Kubernetes wichtig sind, um die Deployment-Anforderung aktivieren zu können, werden im Folgenden einige der wichtigsten Teile hervorgehoben:

Das Feld apiVersion gibt die zu verwendende Kubernetes-API-Version an. Setzen Sie diesen Wert auf apps/v1, wenn Sie eine aktuelle Version von Kubernetes verwenden.
In diesem Fall informiert das Feld Art Kubernetes über den Typ des Objekts Deployment.
Im Abschnitt metadata werden Details des Deployment-Namens und der zugehörigen Labels dargestellt.
Der Abschnitt .spec ist wahrscheinlich der kritischste Abschnitt jeder Deployment-Manifestdatei. Alles von hier nach unten bezieht sich auf das Deployment des Pods. Unter dem Abschnitt .spec.template wird die Podvorlage beschrieben, mit der Kubernetes das Deployment verwaltet (in diesem Beispiel ist dies ein einzelner Container).
Andere Felder, die in diesem Beispiel nicht verwendet werden, sind das Feld .spec.replicas (das Kubernetes anzeigt, wie viele Podreplikationen bereitgestellt werden müssen) und das Feld .spec.strategy (das Kubernetes anweist, wie das Deployment aktualisiert werden soll).

Weitere Informationen zu diesen anderen Feldern finden Sie in der Upstreamdokumentation zu Deployments.

Erstellen Sie die Deployment-Datei.

cat << 'EOF' | tee mydeployment.yaml > /dev/null
apiVersion: apps/v1
kind: Deployment
metadata:
 name: echo1
spec:
 selector:
   matchLabels: 
     app: echo1
 template:
   metadata:
     labels:
       app: echo1
   spec:
     containers:
     - name: echoserver
       image: k8s.gcr.io/echoserver:1.4
EOF

Stellen Sie die Anwendung mit der Deployment-Manifestdatei auf einem Pod bereit.

kubectl apply -f mydeployment.yaml

Beispielausgabe:

[[oracle@ocne-node01 ~]$ kubectl apply -f mydeployment.yaml
deployment.apps/echo1 created

Listen Sie den vom Deployment verwalteten Pod auf.
```
kubectl get pods -l app=echo1
```
Beispielausgabe:
```
[oracle@ocne-node01 ~]$ kubectl get pods -l app=echo1
NAME                     READY   STATUS    RESTARTS   AGE
echo1-7cbf6dfb96-4cgq7   1/1     Running   0          24s
```
- Die Option -l oder --selector= bietet einen Selektor (Labelabfrage), nach dem gefiltert werden soll. Diese Option unterstützt "=", "==" und "!=".(Beispiel: -l key1=value1,key2=value2)
Hinweis: Beachten Sie, dass der Podname einen Suffixwert enthält, der bei jedem Deployment des Pods variiert.
Prüfen Sie, ob das Deployment erfolgreich war.
```
kubectl get deploy echo1
```
Beispielausgabe:
```
[oracle@ocne-node01 ~]$ kubectl get deploy echo1
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
echo1   1/1     1            1           16m
```
- Die Option deploy ist kurz für deployments. Der Befehl kubectl ermöglicht die Verwendung einer abgekürzten Syntax für viele seiner Optionen. Weitere Details finden Sie unter kubectl --help.

Geben Sie detailliertere Informationen für ein Deployment zurück.

kubectl describe deploy echo1

Beispielausgabe:

[oracle@ocne-node01 ~]$ kubectl describe deploy echo1
Name:                   echo1
Namespace:              default
CreationTimestamp:      Tue, 28 Jun 2022 20:20:40 +0000
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=echo1
Replicas:               1 desired | 1 updated | 1 total | 1 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=echo1
  Containers:
   echoserver:
    Image:        k8s.gcr.io/echoserver:1.4
    Port:         <none>
    Host Port:    <none>
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  <none>
NewReplicaSet:   echo1-7cbf6dfb96 (1/1 replicas created)
Events:
  Type    Reason             Age   From                   Message
  ----    ------             ----  ----                   -------
  Normal  ScalingReplicaSet  23m   deployment-controller  Scaled up replica set echo1-7cbf6dfb96 to 1

ClusterIP-Service verwenden

Obwohl das echo1 Deployment erfolgreich für einen Pod bereitgestellt wurde, ist es nicht sinnvoll, wenn die Endbenutzer nicht intern oder im Netzwerk darauf zugreifen können. Bei diesem Zugriff ist ein Service praktisch, da er ein Deployment für das Netzwerk bereitstellt.

Der standardmäßige Kubernetes-Servicetyp lautet ClusterIP. Sie können jedoch nicht über das Internet auf einen ClusterIP-Service zugreifen, aber den Kubernetes-Proxy verwenden. Weitere Informationen finden Sie in der Upstream-Dokumentation unter Proxies.

In diesem Abschnitt wird die echo1-Datei angezeigt, und es wird eine Kommunikation zwischen Services innerhalb des Clusters mit einem Oracle Linux-Pod erstellt. Dort wird die Kommunikation zwischen den Frontend- und Backend-Komponenten Ihrer App demonstriert.

Liste mit Knoten abrufen.

kubectl get nodes

Beispielausgabe:

[oracle@ocne-node01 ~]$ kubectl get nodes
NAME          STATUS   ROLES    AGE     VERSION
ocne-node01   Ready    <none>   4h27m   v1.22.8+1.el8

Knoten sind die physischen Systeme oder virtuellen Maschinen für das Deployment von Pods.

Fragen Sie den kube-proxy-Modus ab.

Wenn Sie kube-proxy im iptables-Modus ausführen, werden Pakete, die an einen ClusterIP-Service gesendet werden, niemals als Quell-NAT bezeichnet.
```
curl -w "\n" http://localhost:10249/proxyMode
```
- kube-proxy horcht auf Port 10249 auf dem Knoten, auf dem er ausgeführt wird.

Erstellen Sie den ClusterIP-Service.

kubectl expose deployment echo1 --name=clusterip-service --port=80 --target-port=8080

Rufen Sie die dem Cluster zugewiesene IP-Adresse ab.

kubectl get svc clusterip-service

Beispielausgabe:

[oracle@ocne-node01 ~]$ kubectl get svc clusterip-service
NAME                TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
clusterip-service   ClusterIP   10.108.107.54   <none>        80/TCP    13s

Notieren Sie sich die CLUSTER-IP-Adresse in der Ausgabe.

Erstellen Sie einen Pod in demselben Cluster für den Zugriff auf den ClusterIP-Service.
```
kubectl run ol -it --image=oraclelinux:8 --restart=Never --rm
```
Mit diesem Befehl wird ein Pod erstellt, auf dem ein Oracle Linux 8-Container im interaktiven Modus ausgeführt wird, und eine Eingabeaufforderung angezeigt wird.
Beispielausgabe:
```
[oracle@ocne-node01 ~]$ kubectl run ol -it --image=oraclelinux:8 --restart=Never --rm
If you don't see a command prompt, try pressing enter.
[root@ol /]#
```

Rufen Sie die IP-Adresse des Oracle Linux-Containers ab.

ip -br a

Beispielausgabe:

[root@ol /]# ip -br a
lo               UNKNOWN        127.0.0.1/8 ::1/128 
eth0@if12        UP             10.244.0.9/24 fe80::146f:2cff:fe73:b528/64

Testen Sie den nginx-Webserver in echo1.

curl -w "\n" <CLUSTER-IP_ADDRESS>

Verwenden Sie die CLUSTER-IP-Adresse aus der vorherigen Ausgabe.

Beispielausgabe:

[root@ol /]# curl -w "\n" 10.108.107.54
CLIENT VALUES:
client_address=10.244.0.9
command=GET
real path=/
query=nil
request_version=1.1
request_uri=http://10.108.107.54:8080/

SERVER VALUES:
server_version=nginx: 1.10.0 - lua: 10001

HEADERS RECEIVED:
accept=*/*
host=10.108.107.54
user-agent=curl/7.61.1
BODY:
-no body in request-

Die Ausgabe zeigt die Anforderung von Oracle Linux an und wird vom ClusterIP-Service mit dem Deployment echo1 verarbeitet.

Beenden Sie den Container.

exit

Beispielausgabe:

[root@ol /]# exit
exit
pod "ol" deleted

NodePort-Service mit einer YAML-Datei verwenden

Zuvor wurde das Deployment echo1 mit dem Befehl kubectl expose angegeben und intern mit ClusterIP zugegriffen. Jetzt verwenden wir einen NodePort-Service. Dieser Ansatz eines Entwicklers ist es, echo1 extern über das Netzwerk zugänglich zu machen.

Der Service NodePort öffnet einen bestimmten Port auf allen Knoten und leitet jeden Traffic an diesen Port an den Service weiter.

Hinweis In der Standard-Praxis wird die Verwendung von NodePort für Produktionssysteme aus mehreren Gründen nicht empfohlen, hauptsächlich aus folgenden Gründen:

Jeder bereitgestellte Service erfordert einen anderen Port
Knoten müssen öffentlich verfügbar sein - dies wird definitiv nicht empfohlen.
Kein Load Balancing auf den Knoten (in einem Kubernetes-Cluster mit mehreren Knoten)

Definieren Sie eine Servicedatei.

cat << 'EOF' | tee myservice.yaml > /dev/null
apiVersion: v1
kind: Service
metadata:
  name: echo1-nodeport
  namespace: default
spec:
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - nodePort: 32387
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: echo1
  sessionAffinity: None
  type: NodePort
status:
  loadBalancer: {}
EOF

type: - Macht den Service für Netzwerkanforderungen von externen Clients verfügbar. Gültige Werte umfassen: nodePort, LooadBalancer.
nodePort: Der externe Port, mit dem auf den Service zugegriffen wird.
Port: - Die im Cluster angegebene Portnummer.
targetPort: Der Port, auf dem der Container horcht.

Erstellen Sie den Service.
```
kubectl apply -f myservice.yaml
```
Beispielausgabe:
```
[oracle@ocne-node01 ~]$ kubectl apply -f myservice.yaml 
service/echo1 created
```
Hinweis: Die Deployment- und Servicedefinitionen müssen sich in derselben YAML-Datei befinden, um die Verwaltung einer Anwendung zu vereinfachen. Die Verwendung separater Dateien in diesen Schritten dient ausschließlich zu Schulungszwecken. Wenn Sie diese in einer einzelnen Datei kombinieren, trennen Sie sie mit der YAML-Syntax ---.

Zeigen Sie an, wie Kubernetes den neu erstellten Service speichert.

kubectl get service echo1-nodeport -o yaml

Beispielausgabe:

[oracle@ocne-node01 ~]$ kubectl get service echo1-nodeport -o yaml
apiVersion: v1
kind: Service
metadata:
  annotations:
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"v1","kind":"Service","metadata":{"annotations":{},"name":"echo1-nodeport","namespace":"default"},"spec":{"ipFamilies":["IPv4"],"ipFamilyPolicy":"SingleStack","ports":[{"nodePort":32387,"port":80,"protocol":"TCP","targetPort":8080}],"selector":{"app":"echo1"},"sessionAffinity":"None","type":"NodePort"},"status":{"loadBalancer":{}}}
  creationTimestamp: "2022-06-29T00:14:30Z"
  name: echo1-nodeport
  namespace: default
  resourceVersion: "6242"
  uid: 3171dda6-05b8-45b8-a0ba-457eab6e4f71
spec:
  clusterIP: 10.100.17.53
  clusterIPs:
  - 10.100.17.53
  externalTrafficPolicy: Cluster
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - nodePort: 32387
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: echo1
  sessionAffinity: None
  type: NodePort
status:
  loadBalancer: {}

Beschreiben Sie den Pods-Service.

kubectl describe svc echo1-nodeport

Beispielausgabe:

[oracle@ocne-node01 ~]$ kubectl describe svc echo1-nodeport
Name:                     echo1-nodeport
Namespace:                default
Labels:                   <none>
Annotations:              <none>
Selector:                 app=echo1
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.100.17.53
IPs:                      10.100.17.53
Port:                     <unset>  80/TCP
TargetPort:               8080/TCP
NodePort:                 <unset>  32387/TCP
Endpoints:                10.244.0.7:8080
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

Objektendpunkte abrufen.

Die Endpunkte verfolgen die IP-Adressen der Pods, an die der Service Traffic sendet.

kubectl get endpoints echo1-nodeport

Beispielausgabe:

[oracle@ocne-node01 ~]$ kubectl get endpoints echo1-nodeport
NAME             ENDPOINTS         AGE
echo1-nodeport   10.244.0.7:8080   8m39s

Listen Sie die Pods auf, auf denen die Anwendung ausgeführt wird.

kubectl get pods --output=wide

Beispielausgabe:

[oracle@ocne-node01 ~]$ kubectl get pods -o wide
NAME                     READY   STATUS    RESTARTS   AGE   IP           NODE          NOMINATED NODE   READINESS GATES
echo1-7cbf6dfb96-mlds4   1/1     Running   0          80m   10.244.0.7   ocne-node01   <none>           <none>
test-6c486b6d76-v4htj    1/1     Running   0          83m   10.244.0.6   ocne-node01   <none>           <none>

Die IP-Adresse in dieser Liste für echo1 muss mit dem Wert übereinstimmen, der im vorherigen Schritt für Endpunkte angegeben wurde. Dies ist die IP-Adresse des Pods, die auf dem angegebenen Knoten ausgeführt wird.

Listen Sie die Services auf.

kubectl get svc -o wide

Beispielausgabe:

[oracle@ocne-node01 ~]$ kubectl get svc -o wide
NAME                TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE   SELECTOR
clusterip-service   ClusterIP   10.107.31.75   <none>        80/TCP         78m   app=echo1
echo1-nodeport      NodePort    10.100.17.53   <none>        80:32387/TCP   10m   app=echo1
kubernetes          ClusterIP   10.96.0.1      <none>        443/TCP        88m   <none>

Dieser Befehl verwendet die alternative Option von -o wide anstelle von --output=wide.

Take note of the NodePort, which is set to 32387 for the echo1-nodeport Service.

Rufen Sie die IP-Adresse des Knotens ab.

Die freie Übungsumgebung wird auf einem einzelnen Knoten ocne-node01 ausgeführt.
```
ip -br a
```
In der Umgebung mit kostenlosen Übungen muss die IP-Adresse die private IP-Adresse der Instanz 10.0.0.140 zurückgeben, die der Schnittstelle ens3 zugewiesen ist.

Verwenden Sie JSONPath, um die Variable NodePort zuzuweisen.

NODEPORT=$(kubectl get -o jsonpath="{.spec.ports[0].nodePort}" services echo1-nodeport)

Verwenden Sie JSONPath, um die Knoten-IP einer Variablen zuzuweisen.

NODES=$(kubectl get nodes -o jsonpath='{ $.items[*].status.addresses[?(@.type=="InternalIP")].address }')

Erstellen Sie eine Firewallregel.

Diese Regel ermöglicht Traffic auf node:nodeport, wobei node die Host-IP-Adresse des Systems oder der virtuellen Maschine ist, auf dem der Pod ausgeführt wird.
```
sudo firewall-cmd --permanent --add-port=$NODEPORT/tcp
sudo firewall-cmd --reload
```
Nach der --reload lädt der Firewalld-Daemon seine Konfiguration neu, einschließlich iptables. Da kube-proxy von iptables abhängt, wird die Antwort von Services verzögert.
Prüfen Sie die Anwendung mit Knotenadresse und Knotenport.
```
curl -s $NODES:$NODEPORT
```
Beispielausgabe:
```
[oracle@ocne-node01 ~]$ curl -s $NODES:NODEPORT
CLIENT VALUES:
client_address=10.244.0.1
command=GET
real path=/
query=nil
request_version=1.1
request_uri=http://10.0.0.140:8080/

SERVER VALUES:
server_version=nginx: 1.10.0 - lua: 10001

HEADERS RECEIVED:
accept=*/*
host=10.0.0.140:32387
user-agent=curl/7.61.1
BODY:
```
Die Ausgabe zeigt die Anforderung vom Routing des lokalen Knotens über den NodePort-Service, über kube-proxy und zum Pod, auf dem das Deployment echo1 ausgeführt wird.

Hinweis: Wenn die Ausgabe hängen scheint, ist dies auf das vorherige erneute Laden der Firewall zurückzuführen. Geben Sie Ctrl-C ein, und versuchen Sie es erneut.

Deployments und Services entfernen

Entfernen Sie diese anschließend mit einem Service oder Deployment aus Kubernetes.

Services entfernen.

kubectl delete svc clusterip-service echo1-nodeport

Deployments entfernen.

kubectl delete deployments echo1
kubectl delete deploy test

Das Entfernen von Objekten kann einzeln oder in Gruppen erfolgen. Weitere Informationen finden Sie im Kubernetes-Referenzhandbuch.

Übersicht

Diese Übung bietet nur eine Einführung in die Funktionalität, die mit einem Cloud-nativen Orchestrator wie Kubernetes jedem Unternehmen bereitgestellt wird, das Kubernetes zur Verwaltung seiner Container-Deployments verwendet. Diese Übungen stellen den ersten Schritt dar, der wahrscheinlich eine lange Reise in die Flexibilität ermöglicht, die Kubernetes bereitstellen kann.

Weitere Informationen

Weitere Lernressourcen

Sehen Sie sich andere Übungen auf der Website docs.oracle.com/learn an, oder greifen Sie auf Inhalte zu, die Sie über den Oracle Learning-Kanal YouTube benötigen. Besuchen Sie außerdem education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Produktdokumentation finden Sie unter Oracle Help Center.

Titel und Copyright-Informationen

Run Kubernetes on Oracle Linux

F59595-01

June 2022