Kubernetes mit Code Engine verwenden

IBM Cloud® Code Engine ist so konzipiert, dass Sie nicht mit der zugrundeliegenden Technologie interagieren müssen, auf der es basiert. Wenn Sie jedoch bereits über Tools verfügen, die auf Kubernetes oder Knative basieren, können Sie sie weiterhin mit Code Engineverwenden. Code Engine unterstützt die Kubernetes-APIs (und Knative-APIs) sowie deren CLI-Befehle. Weitere Informationen zu Knative finden Sie unter Knative mit Code Engine verwenden.

Wenn Sie sich dafür entscheiden, „ Kubernetes “ zusammen mit „ Code Engine “ zu verwenden, beachten Sie bitte die folgenden Hinweise:

Die meisten Container oder Pods, die in Kubernetes ausgeführt werden, sind auch mit Code Engine kompatibel.
Kubernetes-Konstrukte, wie z. B. Bereitstellungen, werden in Code Engine ausgeführt, wenn sie keine clusterweiten Funktionen wie Sicherheitsrichtlinien verwenden. Code Engine gilt für das, was in einem Kubernetes-Namensbereich ausgeführt werden kann.

Code Engine unterstützt keine OpenShift-spezifischen Ressourcen oder andere Containerorchestrierungsplattformen wie Docker Swarm oder Compose Swarm.

Kubernetes-Befehlszeilenschnittstelle installieren

Um die CLI „ Kubernetes “ zu installieren, laden Sie die CLI „ kubectl “ herunter und installieren Sie sie.

Denken Sie daran, die Binärdateien für kubectl zur Umgebungsvariablen PATH des Systems hinzufügen.

Mit der Kubernetes-API interagieren

Um mit Ihrem Projekt über die Kubernetes-Befehlszeilenschnittstelle kubectl oder mit Knative kn zu interagieren, müssen Sie Ihre Umgebung so einrichten, dass sie mit der Kubernetes-API von Code Engine interagiert.

Vorbereitende Schritte

Sie müssen Ihr Projekt erstellen und das Projekt muss den Status active aufweisen.
Installieren Sie die Kubernetes-Befehlszeilenschnittstelle (kubectl) und die Knative-Befehlszeilenschnittstelle (kn).

Sie können die Umgebung auf die folgenden Arten einrichten.

Sie können die Option --kubecfg zum Befehl project select hinzufügen. Beispiel:
```
ibmcloud ce project select --name PROJECT_NAME --kubecfg
```

Sie können die Datei kubeconfig direkt exportieren. Führen Sie den Befehl ibmcloud ce project current aus, um das Projekt zu finden, das Sie gerade als Ziel angeben. Mit diesem Befehl wird auch der Befehl export für Ihre Datei kubeconfig zurückgegeben. Beispiel:

ibmcloud ce project current

Beispielausgabe

Getting the current project context...
OK
Name:       myproject
ID:         01234567-abcd-abcd-abcd-abcdabcd1111
Subdomain:  aabon2dfwa0
Domain:     us-south.codeengine.appdomain.cloud
Region:     us-south
Kubectl Context:  4svg40kna19
Kubernetes Config:
Context:             aabon2dfwa0
Environment Variable: export KUBECONFIG=/user/myusername/.bluemix/plugins/code-engine/myproject-01234567-abcd-abcd-abcd-abcdabcd1111.yaml

Kopieren Sie anschließend den Exportbefehl, fügen Sie ihn in die Befehlszeilenschnittstelle ein und führen Sie ihn aus.

Überprüfen Sie durch Ausführen des Befehls kubectl config, ob die Umgebung ordnungsgemäß konfiguriert ist.

kubectl config current-context

Wenn der Kontext ordnungsgemäß konfiguriert ist, stimmt die Ausgabe mit dem Wert von Kubectl Context des Projekts überein. Beispiel: Wenn der Wert von Kubectl Context für das Projekt 4svg40kna19 beträgt, wird vom Befehl 4svg40kna19 zurückgegeben.

Weitere Informationen zu Kubernetes und zur Zusammenarbeit mit der Code Engine-Architektur finden Sie unter Lernen Sie die Code Engine-Architektur und Workloadisolation kennen.

Erforderliche Zugriffsberechtigungen für die Arbeit mit der Kubernetes-API

Nachdem Sie Ihre Umgebung eingerichtet haben, können Sie mit der Kubernetes-API interagieren. Für bestimmte Tasks müssen Sie die richtige Berechtigungsstufe besitzen. Diese Rollen werden in Identity and Access Management festgelegt. Weitere Informationen enthält der Abschnitt IBM Cloud-Servicerollen.

Kubernetes
Ressource	Rolle für Managementaufgaben	Schreibberechtigter (Autor)	Leserrolle
`serviceaccounts`	`get`, `list`, `watch`	`get`, `list`, `watch`	Keine
`secrets`	`get`, `list`, `watch`, `create`, `delete`, `update`, `patch`, `apply`, `edit`	`get`, `list`, `watch`, `create`, `delete`, `update`, `patch`, `apply`, `edit`	Keine
`configmaps`	`get`, `list`, `watch`, `create`, `delete`, `update`, `patch`, `apply`, `edit`	`get`, `list`, `watch`, `create`, `delete`, `update`, `patch`, `apply`, `edit`	Keine
`events`	`get`, `list`, `watch`	`get`, `list`, `watch`	Keine
`pods/log`	`get`, `list`, `watch`	`get`, `list`, `watch`	`get`, `list`, `watch`
`pods`	`get`, `list`, `watch`, `create`, `delete`, `patch`, `apply`	`get`, `list`, `watch`, `create`, `delete`, `patch`, `apply`	`get`, `list`, `watch`
`services`	`get`, `list`, `watch`, `create`, `delete`, `patch`, `apply`	`get`, `list`, `watch`, `create`, `delete`, `patch`, `apply`	`get`, `list`, `watch`
`pods/exec`	`create`	`create`	Keine
`pods/portforward`	`create`	`create`	Keine
`pods/attach`	`create`	Keine	Keine
`pods/status`	`get`, `list`	`get`, `list`	Keine
`resourcequotas`	`get`, `list`, `watch`	`get`, `list`, `watch`	get, list, watch
`limitranges`	`get`, `list`, `watch`	`get`, `list`, `watch`	Keine
`deployments`	`get`, `list`, `watch`, `create`, `delete`, `patch`, `apply`	`get`, `list`, `watch`, `create`, `delete`, `patch`, `apply`	`get`, `list`, `watch`
`daemonset`	`get`, `list`, `watch`	`get`, `list`, `watch`	`get`, `list`, `watch`
`pods.metrics.k8s.io`	Liste	Liste	Liste

Kubernetes-Konfiguration abrufen

Sie können Ihre Kubernetes-Konfiguration mit der REST API oder der Code Engine-CLI abrufen.

Kubernetes-Konfiguration über REST-API abrufen

Führen Sie die folgenden Schritte aus, um Ihre Kubernetes-Konfiguration über die REST-API abzurufen:

Authentifizieren Sie sich bei IBM Cloud® Identity and Access Management (IAM) für den Empfang eines IAM-Zugriffstokens.
Fragen Sie den IBM Cloud-Katalog und den IBM Cloud.Ressourcencontroller ab, um eine GUID für Ihr Projekt zu erhalten.
Verwenden Sie die IBM Cloud Code Engine-API, um eine Kubernetes-Konfiguration zu erhalten.

Bei Cloud Identity and Access Management authentifizieren

Erstellen Sie Ihr IBM Cloud IAM-Zugriffstoken, indem Sie eine POST-Anforderung an https://iam.cloud.ibm.com/identity/token absetzen.

GUID des Code Engine-Projekts ermitteln

Ermitteln Sie die GUID Ihres Code Engine-Projekts durch Abfragen des IBM Cloud-Katalogs und des IBM Cloud-Katalogs. Da sich diese GUID nicht ändert, müssen Sie diesen Schritt nur ein einziges Mal ausführen. Wenn Sie die GUID für das Code Engine-Projekt bereits kennen, können Sie diesen Schritt überspringen.

Führen Sie die folgenden Schritte aus, um die GUID Ihres Code Engine-Projekts mithilfe der Befehlszeilenschnittstelle Code Engine zu erkennen:

Melden Sie sich bei IBM Cloud an und legen Sie eine Region, ein Konto und eine Ressourcengruppe als Ziel fest.
```
ibmcloud login target -r REGION -c ACCOUNT_ID -g RESOURCE_GROUP
```

Führen Sie den Befehl ibmcloud resource aus.

ibmcloud resource service-instances --service-name codeengine --long

Geben Sie die Serviceinstanz für das Code Engine-Projekt an und ermitteln Sie die GUID aus der Ausgabe.

Führen Sie die folgenden Schritte durch, um die REST-API für die Erkennung der GUID Ihres Code Engine-Projekts zu verwenden:

Bevor Sie beginnen, müssen Sie über den Wert für access_token aus dem vorherigen Schritt verfügen.

Verwenden Sie die folgende IBM Cloud-Katalog-API-Methode: Gibt übergeordnete Katalogeinträge zurück.

Beispielausgabe
```
curl -X GET \
  'https://globalcatalog.cloud.ibm.com/api/v1?include=*&q=name:codeengine+active:true' \
  -H 'Authorization: Bearer ACCESS_TOKEN'
```
Geben Sie die eindeutige Ressourcen-ID in der Ressourcenliste an. Der Feldname ist ID und der JSON-Pfad lautet resources[].id.
Fragen Sie den „ IBM Cloud “-Ressourcen-Controller mit der API-Methode „ Get a list of all resource instances “ des „ IBM Cloud “-Ressourcen-Controllers ab. Sie müssen über den Code Engine-Projektnamen, die Region, in der sich das Projekt befindet, und die eindeutige Ressourcen-ID von Code Engine im globalen Katalog verfügen. Verwenden Sie den Namen des Code Engine-Projekts als Abfrageparameter.

Beispielausgabe
```
curl -X GET \
    'https://resource-controller.cloud.ibm.com/v2/resource_instances?name=MY_PROJECT&resource_id=RESOURCE_ID' \
    -H 'Authorization: Bearer ACCESS_TOKEN'
```
Ermitteln Sie das Code Engine-Projekt in der Region in der Ergebnisliste. Suchen Sie die Ausgabe von guid, die Sie in den nächsten Schritten verwenden.

IBM Code Engine-API abfragen

Bevor Sie beginnen, müssen Sie über die folgenden Informationen verfügen.

Die Werte für access_token und refresh_token aus den vorherigen Schritten.
Der Wert für guid des Code Engine-Projekts.
Die Region, in der sich das Code Engine-Projekt befindet.

Verwenden Sie die get kubeconfig for the specified projectCode Engine API-Methode, um die Konfiguration von „ Kubernetes “ abzurufen.

Beispielausgabe

curl -X GET \
    'https://resource-controller.cloud.ibm.com/v2/resource_instances?name=MY_PROJECT&resource_id=RESOURCE_ID' \
    -H 'Authorization: Bearer ACCESS_TOKEN'

Rufen Sie Ihre „ Kubernetes “-Konfiguration mit der „ Code Engine “-CLI ab

Melden Sie sich bei IBM Cloud an und legen Sie eine Region, ein Konto und eine Ressourcengruppe als Ziel fest.
```
ibmcloud login target -r REGION -c ACCOUNT_ID -g RESOURCE_GROUP
```

Erstellen Sie Ihr Code Engine-Projekt:

ibmcloud ce project create --name PROJECT

Wählen Sie Ihr Code Engine-Projekt als aktuellen Kontext aus und hängen Sie das Projekt an die Kubernetes-Standardkonfigurationsdatei an.
```
ibmcloud ce project select --name PROJECT --kubecfg
```

Sie können nun kubectl-Befehle für Ihr Projekt verwenden.

Weitere Informationen zur Verwendung von Code Engine-APIs, der Kubernetes-API und von kubectl finden Sie in den folgenden Abschnitten:

Angepasste Ressourcendefinition (Custom Resource Definition, CRD)

In den folgenden Abschnitten werden die Methoden der angepassten Ressourcendefinition aufgelistet, die für die Verwendung mit Code Engine vorgesehen sind.

CRD-Methoden für Stapelbetrieb

Sie können Stapel-CRDs verwenden, wenn Sie mit Jobs und Jobausführungen in Code Enginearbeiten.

Stapel-CRDs für Code Engine
Gruppe	Version	Art
`codeengine.cloud.ibm.com`	v1beta1	`JobDefinition`
`codeengine.cloud.ibm.com`	v1beta1	`JobRun`

Nach dem Abrufen der Kubernetes-Konfiguration können Sie die CRD-Details für den Stapelbetrieb mithilfe der folgenden Methoden anzeigen.

Verwenden Sie kubectl explain --api-version='codeengine.cloud.ibm.com/v1beta1' <Kind>.
Laden Sie die Swagger- oder „ OpenAPI “-Spezifikation der CRDs herunter.

Beachten Sie, dass Sie eine Jobausführung nicht löschen können, ohne auch alle zugeordneten Pods zu löschen. Löschanforderungen mit der Option propagationPolicy=Orphan werden zurückgewiesen.

CRD-Funktionsmethoden

Sie können Funktions-CRDs verwenden, wenn Sie mit Funktionen in Code Enginearbeiten.

Funktions-CRDs für Code Engine
Gruppe	Version	Art
`codeengine.cloud.ibm.com`	v1beta1	`Function`

CRD-Methoden bereitstellen

Sie können die Bereitstellung von CRDs verwenden, wenn Sie mit Anwendungen in Code Enginearbeiten.

CRDs für Code Engine
Gruppe	Version	Art
`serving.knative.dev`	v1	`Configuration`
`serving.knative.dev`	v1	`Revision`
`serving.knative.dev`	v1	`Route`
`serving.knative.dev`	v1	`Service`

Weitere Informationen zu diesen CRDs finden Sie in der Knative Serving-API-Spezifikation.

Quelle-zu-Image-CRD-Methoden

Sie können Quellen-zu-Image-CRDs verwenden, wenn die Arbeit mit Builds und Builds in Code Engineausgeführt wird.

Quellen-zu-Image-CRDs für Code Engine
Gruppe	Version	Art
`shipwright.io`	v1beta1	`Build`
`shipwright.io`	v1beta1	`BuildRun`

Nach dem Abrufen der Kubernetes-Konfiguration können Sie die CRD-Details für Source-to-Image mithilfe einer der folgenden Methoden anzeigen.

Verwenden Sie kubectl explain --api-version='shipwright.io/v1beta1' <KIND>.
Laden Sie die Swagger- oder „ OpenAPI “-Spezifikation der CRDs herunter.

CRD-Methoden für Abonnements

Sie können Subskriptions-CRDs verwenden, wenn Sie mit Subskriptionen in Code Enginearbeiten.

Subskriptions-CRDs für Code Engine
Gruppe	Version	Art
`sources.codeengine.cloud.ibm.com`	v1alpha1	`CosSource`
`sources.knative.dev`	v1beta1	`KafkaSource`
`sources.knative.dev`	v1	`PingSource`

Nach dem Abrufen der Kubernetes-Konfiguration können Sie die CRD-Details für Abonnements mithilfe einer der folgenden Methoden anzeigen.

Verwenden Sie kubectl explain --api-version='sources.knative.dev/<VERSION>' <KIND>.
Laden Sie die Swagger- oder „ OpenAPI “-Spezifikation der CRDs herunter.