Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Einrichtung und Verwendung des Flink Kubernetes-Operators
Auf den folgenden Seiten wird beschrieben, wie Sie den Flink-Kubernetes-Operator einrichten und verwenden, um Flink-Aufträge mit Amazon EMR in EKS auszuführen. Zu den verfügbaren Themen gehören die erforderlichen Voraussetzungen, die Einrichtung Ihrer Umgebung und die Ausführung einer Flink-Anwendung auf Amazon EMR auf EKS.
**Topics**
+ [Flink-Kubernetes-Operator für Amazon EMR in EKS einrichten](jobruns-flink-kubernetes-operator-setup.md)
+ [Installation des Flink Kubernetes-Operators für Amazon EMR auf EKS](jobruns-flink-kubernetes-operator-getting-started.md)
+ [Eine Flink-Anwendung ausführen](jobruns-flink-kubernetes-operator-run-application.md)
+ [Sicherheitsrollen, Berechtigungen für die Ausführung einer Flink-Anwendung](jobruns-flink-kubernetes-security.md)
+ [Flink-Kubernetes-Operator für Amazon EMR in EKS deinstallieren](jobruns-flink-kubernetes-operator-uninstall.md)
# Flink-Kubernetes-Operator für Amazon EMR in EKS einrichten
Führen Sie zum Einrichten des Flink-Kubernetes-Operator auf Amazon EKS die folgenden Schritte aus. Wenn Sie bereits für Amazon Web Services (AWS) registriert sind und Amazon EKS schon verwendet haben, müssen Sie nur wenige Schritte ausführen, um Amazon EMR in EKS nutzen zu können. Führen Sie zum Einrichten von Flink-Operator die folgenden Schritte auf Amazon EKS aus. Wenn Sie bereits eine der Voraussetzungen erfüllt haben, können Sie diese überspringen und mit der nächsten fortfahren.
+ **[Installation oder Aktualisierung auf die neueste Version von AWS CLI— Falls Sie die](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)** bereits installiert haben, vergewissern Sie sich AWS CLI, dass Sie über die neueste Version verfügen.
+ **[Richten Sie kubectl und eksctl ein — eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)** ist ein Befehlszeilentool, das Sie für die Kommunikation mit Amazon EKS verwenden.
+ **[Helm installieren](https://docs.aws.amazon.com/eks/latest/userguide/helm.html)** – Der Helm-Paketmanager für Kubernetes unterstützt Sie bei der Installation und Verwaltung von Anwendungen in Ihrem Kubernetes-Cluster.
+ **[Erste Schritte mit Amazon EKS — eksctl —](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)** Folgen Sie den Schritten, um einen neuen Kubernetes-Cluster mit Knoten in Amazon EKS zu erstellen.
+ **[Wählen Sie ein Amazon EMR-Release-Label](jobruns-flink-security-release-versions.md) (Version 6.13.0 oder höher)** — der Flink Kubernetes-Operator wird mit Amazon EMR-Versionen 6.13.0 und höher unterstützt.
+ **[Aktivieren Sie IAM-Rollen für Servicekonten](setting-up-enable-IAM.md)** (IRSA) auf dem Amazon-EKS-Cluster.
+ **[Erstellen einer Aufgaben-Ausführungsrolle](creating-job-execution-role.md)**.
+ **[Aktualisieren Sie die Vertrauensrichtlinie der Auftragausführungsrolle](setting-up-trust-policy.md)**.
+ Erstellen Sie eine Operator-Ausführungsrolle. Dieser Schritt ist optional. Sie können die gleiche Rolle für Flink-Aufträge und -Operator verwenden. Wenn Sie eine andere IAM-Rolle für Ihren Operator haben möchten, können Sie eine separate Rolle erstellen.
+ Aktualisieren Sie die Vertrauensrichtlinie der Operatorausführungsrolle. Sie müssen explizit einen Vertrauensrichtlinieneintrag für die Rollen hinzufügen, die Sie für das Flink-Kubernetes-Operator-Servicekonto von Amazon EMR verwenden möchten. Sie können diesem Beispielformat folgen:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sts:AssumeRoleWithWebIdentity"
],
"Resource": [
"*"
],
"Condition": {
"StringLike": {
"aws:userid": "system:serviceaccount:emr:emr-containers-sa-flink-operator"
}
},
"Sid": "AllowSTSAssumerolewithwebidentity"
}
]
}
```
------
# Installation des Flink Kubernetes-Operators für Amazon EMR auf EKS
Dieses Thema hilft Ihnen beim Einstieg in die Verwendung des Flink Kubernetes-Operators auf Amazon EKS, indem Sie eine Flink-Bereitstellung vorbereiten.
## Installieren Sie den Kubernetes-Operator
Gehen Sie wie folgt vor, um den Kubernetes-Operator für Apache Flink zu installieren.
1. Sofern noch nicht geschehen, führen die Schritte unter [Flink-Kubernetes-Operator für Amazon EMR in EKS einrichten](jobruns-flink-kubernetes-operator-setup.md) aus.
1. Installieren Sie das *cert-manager* (einmal pro Amazon EKS-Cluster), um das Hinzufügen der Webhook-Komponente zu ermöglichen.
```
kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.12.0/cert-manager.yaml
```
1. Installieren Sie das Helm-Chart.
```
export VERSION=7.12.0 # The Amazon EMR release version
export NAMESPACE=The Kubernetes namespace to deploy the operator
helm install flink-kubernetes-operator \
oci://public.ecr.aws/emr-on-eks/flink-kubernetes-operator \
--version $VERSION \
--namespace $NAMESPACE
```
Beispielausgabe:
```
NAME: flink-kubernetes-operator
LAST DEPLOYED: Tue May 31 17:38:56 2022
NAMESPACE: $NAMESPACE
STATUS: deployed
REVISION: 1
TEST SUITE: None
```
1. Warten Sie, bis die Bereitstellung abgeschlossen ist, und überprüfen Sie die Installation des Diagramms.
```
kubectl wait deployment flink-kubernetes-operator --namespace $NAMESPACE --for condition=Available=True --timeout=30s
```
1. Die Ausgabe sollte folgendermaßen aussehen, wenn die Bereitstellung abgeschlossen ist.
```
deployment.apps/flink-kubernetes-operator condition met
```
1. Verwenden Sie den folgenden Befehl, um den bereitgestellten Operator zu sehen.
```
helm list --namespace $NAMESPACE
```
Im Folgenden wird eine Beispielausgabe gezeigt, bei der die Anwendungsversion `x.y.z-amzn-n` der Flink-Operator-Version für Ihre Amazon EMR in EKS-Version entsprechen würde. Weitere Informationen finden Sie unter [Unterstützte Versionen für Amazon EMR in EKS mit Apache Flink](jobruns-flink-security-release-versions.md).
```
NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
flink-kubernetes-operator $NAMESPACE 1 2023-02-22 16:43:45.24148 -0500 EST deployed flink-kubernetes-operator-emr-7.12.0 x.y.z-amzn-n
```
### Führen Sie ein Upgrade des Kubernetes-Operators durch
Gehen Sie folgendermaßen vor, um die Version des Flink-Operators zu aktualisieren:
1. Deinstalliere das alte`flink-kubernetes-operator`:`helm uninstall flink-kubernetes-operator -n `.
1. CRD löschen (da Helm die alte CRD nicht automatisch löscht):. `kubectl delete crd flinkdeployments.flink.apache.org flinksessionjobs.flink.apache.org`
1. Installieren Sie es erneut `flink-kubernetes-operator` mit der neueren Version.
# Eine Flink-Anwendung ausführen
Mit Amazon EMR 6.13.0 und höher können Sie eine Flink-Anwendung mit dem Flink-Kubernetes-Operator im Anwendungsmodus in Amazon EMR in EKS ausführen. Mit Amazon EMR 6.15.0 und höher können Sie eine Flink-Anwendung auch im Sitzungsmodus ausführen. Auf dieser Seite werden beide Methoden beschrieben, mit denen Sie eine Flink-Anwendung mit Amazon EMR in EKS ausführen können.
**Topics**
**Anmerkung**
Sie müssen einen Amazon-S3-Bucket erstellt haben, um die Hochverfügbarkeitsmetadaten zu speichern, wenn Sie Ihren Flink-Auftrag einreichen. Wenn Sie dieses Feature nicht verwenden möchten, können Sie sie deaktivieren. Sie ist standardmäßig aktiviert.
**Voraussetzung** – Bevor Sie eine Flink-Anwendung mit dem Flink-Kubernetes-Operator ausführen können, führen Sie die Schritte in [Flink-Kubernetes-Operator für Amazon EMR in EKS einrichten](jobruns-flink-kubernetes-operator-setup.md) und [Installieren Sie den Kubernetes-Operator](jobruns-flink-kubernetes-operator-getting-started.md#jobruns-flink-kubernetes-operator-getting-started-install-operator) aus.
------
#### [ Application mode ]
Mit Amazon EMR 6.13.0 und höher können Sie eine Flink-Anwendung mit dem Flink-Kubernetes-Operator im Anwendungsmodus in Amazon EMR in EKS ausführen.
1. Erstellen Sie eine `FlinkDeployment` Definitionsdatei `basic-example-app-cluster.yaml` wie im folgenden Beispiel. Wenn Sie eines der [Opt-ins](https://docs.aws.amazon.com/controltower/latest/userguide/opt-in-region-considerations.html) aktiviert und verwendet haben, stellen Sie sicher AWS-Regionen, dass Sie das Kommentarfeld entfernen und die Konfiguration konfigurieren. `fs.s3a.endpoint.region`
```
apiVersion: flink.apache.org/v1beta1
kind: FlinkDeployment
metadata:
name: basic-example-app-cluster
spec:
flinkConfiguration:
taskmanager.numberOfTaskSlots: "2"
#fs.s3a.endpoint.region: OPT_IN_AWS_REGION_NAME
state.checkpoints.dir: CHECKPOINT_S3_STORAGE_PATH
state.savepoints.dir: SAVEPOINT_S3_STORAGE_PATH
flinkVersion: v1_17
executionRoleArn: JOB_EXECUTION_ROLE_ARN
emrReleaseLabel: "emr-6.13.0-flink-latest" # 6.13 or higher
jobManager:
storageDir: HIGH_AVAILABILITY_STORAGE_PATH
resource:
memory: "2048m"
cpu: 1
taskManager:
resource:
memory: "2048m"
cpu: 1
job:
# if you have your job jar in S3 bucket you can use that path as well
jarURI: local:///opt/flink/examples/streaming/StateMachineExample.jar
parallelism: 2
upgradeMode: savepoint
savepointTriggerNonce: 0
monitoringConfiguration:
cloudWatchMonitoringConfiguration:
logGroupName: LOG_GROUP_NAME
```
1. Senden Sie die Flink-Bereitstellung mit dem folgenden Befehl. Dadurch wird auch ein `FlinkDeployment`-Objekt mit dem `basic-example-app-cluster`-Namen erstellt.
```
kubectl create -f basic-example-app-cluster.yaml -n
```
1. Greifen Sie auf die Flink-Benutzeroberfläche zu.
```
kubectl port-forward deployments/basic-example-app-cluster 8081 -n NAMESPACE
```
1. Öffnen Sie `localhost:8081`, um Ihre Flink-Aufträge lokal anzusehen.
1. Bereinigen Sie den Auftrag. Denken Sie daran, die S3-Artefakte zu bereinigen, die für diesen Job erstellt wurden, z. B. Checkpointing-, Hochverfügbarkeits-, Savepointing-Metadaten und Protokolle. CloudWatch
[Weitere Informationen zum Einreichen von Bewerbungen über den Flink-Kubernetes-Operator an Flink finden Sie unter Beispiele für Flink-Kubernetes-Operatoren im Ordner unter.](https://github.com/apache/flink-kubernetes-operator/tree/main/examples) `apache/flink-kubernetes-operator` GitHub
------
#### [ Session mode ]
Mit Amazon EMR 6.15.0 und höher können Sie eine Flink-Anwendung mit dem Flink-Kubernetes-Operator im Sitzungsmodus in Amazon EMR in EKS ausführen.
1. Erstellen Sie eine `FlinkDeployment` Definitionsdatei mit dem Namen im folgenden Beispiel. `basic-example-app-cluster.yaml` Wenn Sie eines der [Opt-ins](https://docs.aws.amazon.com/controltower/latest/userguide/opt-in-region-considerations.html) aktiviert und verwendet haben, stellen Sie sicher AWS-Regionen, dass Sie das Kommentarfeld entfernen und die Konfiguration konfigurieren. `fs.s3a.endpoint.region`
```
apiVersion: flink.apache.org/v1beta1
kind: FlinkDeployment
metadata:
name: basic-example-session-cluster
spec:
flinkConfiguration:
taskmanager.numberOfTaskSlots: "2"
#fs.s3a.endpoint.region: OPT_IN_AWS_REGION_NAME
state.checkpoints.dir: CHECKPOINT_S3_STORAGE_PATH
state.savepoints.dir: SAVEPOINT_S3_STORAGE_PATH
flinkVersion: v1_17
executionRoleArn: JOB_EXECUTION_ROLE_ARN
emrReleaseLabel: "emr-6.15.0-flink-latest"
jobManager:
storageDir: HIGH_AVAILABILITY_S3_STORAGE_PATH
resource:
memory: "2048m"
cpu: 1
taskManager:
resource:
memory: "2048m"
cpu: 1
monitoringConfiguration:
s3MonitoringConfiguration:
logUri:
cloudWatchMonitoringConfiguration:
logGroupName: LOG_GROUP_NAME
```
1. Senden Sie die Flink-Bereitstellung mit dem folgenden Befehl. Dadurch wird auch ein `FlinkDeployment`-Objekt mit dem `basic-example-session-cluster`-Namen erstellt.
```
kubectl create -f basic-example-app-cluster.yaml -n NAMESPACE
```
1. Verwenden Sie den folgenden Befehl, um zu bestätigen, dass der Sitzungscluster `LIFECYCLE` `STABLE` ist:
```
kubectl get flinkdeployments.flink.apache.org basic-example-session-cluster -n NAMESPACE
```
Die Ausgabe sollte ähnlich wie im folgenden Beispiel aussehen:
```
NAME JOB STATUS LIFECYCLE STATE
basic-example-session-cluster STABLE
```
1. Erstellen Sie eine `FlinkSessionJob`-Aufgabendefinitions-Datei `basic-session-job.yaml` mit dem folgenden Beispielinhalt:
```
apiVersion: flink.apache.org/v1beta1
kind: FlinkSessionJob
metadata:
name: basic-session-job
spec:
deploymentName: basic-session-deployment
job:
# If you have your job jar in an S3 bucket you can use that path.
# To use jar in S3 bucket, set
# OPERATOR_EXECUTION_ROLE_ARN (--set emrContainers.operatorExecutionRoleArn=$OPERATOR_EXECUTION_ROLE_ARN)
# when you install Spark operator
jarURI: https://repo1.maven.org/maven2/org/apache/flink/flink-examples-streaming_2.12/1.16.1/flink-examples-streaming_2.12-1.16.1-TopSpeedWindowing.jar
parallelism: 2
upgradeMode: stateless
```
1. Reichen Sie den Flink-Sitzungsauftrag mit dem folgenden Befehl ein. Dadurch wird auch ein `FlinkSessionJob`-Objekt `basic-session-job` erstellt.
```
kubectl apply -f basic-session-job.yaml -n $NAMESPACE
```
1. Verwenden Sie den folgenden Befehl, um zu bestätigen, dass der Sitzungscluster `LIFECYCLE` `STABLE` und dass der `JOB STATUS` `RUNNING` ist:
```
kubectl get flinkdeployments.flink.apache.org basic-example-session-cluster -n NAMESPACE
```
Die Ausgabe sollte ähnlich wie im folgenden Beispiel aussehen:
```
NAME JOB STATUS LIFECYCLE STATE
basic-example-session-cluster RUNNING STABLE
```
1. Greifen Sie auf die Flink-Benutzeroberfläche zu.
```
kubectl port-forward deployments/basic-example-session-cluster 8081 -n NAMESPACE
```
1. Öffnen Sie `localhost:8081`, um Ihre Flink-Aufträge lokal anzusehen.
1. Bereinigen Sie den Auftrag. Denken Sie daran, die S3-Artefakte zu bereinigen, die für diesen Job erstellt wurden, z. B. Checkpointing-, Hochverfügbarkeits-, Savepointing-Metadaten und Protokolle. CloudWatch
------
# Sicherheitsrollen, Berechtigungen für die Ausführung einer Flink-Anwendung
In diesem Thema werden Sicherheitsrollen für die Bereitstellung und Ausführung einer Flink-Anwendung beschrieben. Für die Verwaltung einer Bereitstellung sowie für die Erstellung und Verwaltung von Jobs sind zwei Rollen erforderlich: die Operatorrolle und die Jobrolle. In diesem Thema werden sie vorgestellt und ihre Berechtigungen aufgeführt.
## Rollenbasierte Zugriffskontrolle
Um den Operator bereitzustellen und Flink-Aufträge auszuführen, müssen wir zwei Kubernetes-Rollen erstellen: eine Operator- und eine Auftrag-Rolle. Amazon EMR erstellt die beiden Rollen standardmäßig, wenn Sie den Operator installieren.
## Rolle des Operators
Wir verwenden die Operator-Rolle, um den JobManager Flink-Job und andere Ressourcen, wie Dienste, `flinkdeployments` zu verwalten, zu erstellen und zu verwalten.
Der Standardname der Operatorrolle lautet `emr-containers-sa-flink-operator` und erfordert die folgenden Berechtigungen.
```
rules:
- apiGroups:
- ""
resources:
- pods
- services
- events
- configmaps
- secrets
- serviceaccounts
verbs:
- '*'
- apiGroups:
- rbac.authorization.k8s.io
resources:
- roles
- rolebindings
verbs:
- '*'
- apiGroups:
- apps
resources:
- deployments
- deployments/finalizers
- replicasets
verbs:
- '*'
- apiGroups:
- extensions
resources:
- deployments
- ingresses
verbs:
- '*'
- apiGroups:
- flink.apache.org
resources:
- flinkdeployments
- flinkdeployments/status
- flinksessionjobs
- flinksessionjobs/status
verbs:
- '*'
- apiGroups:
- networking.k8s.io
resources:
- ingresses
verbs:
- '*'
- apiGroups:
- coordination.k8s.io
resources:
- leases
verbs:
- '*'
```
## Aufgabenrolle
Der JobManager verwendet die Job-Rolle zur Erstellung TaskManagers und Verwaltung sowie ConfigMaps für jeden Job.
```
rules:
- apiGroups:
- ""
resources:
- pods
- configmaps
verbs:
- '*'
- apiGroups:
- apps
resources:
- deployments
- deployments/finalizers
verbs:
- '*'
```
# Flink-Kubernetes-Operator für Amazon EMR in EKS deinstallieren
Gehen Sie wie folgt vor, um den Flink-Kubernetes-Operator zu deinstallieren.
1. Löschen Sie den Operator.
```
helm uninstall flink-kubernetes-operator -n
```
1. Löschen Sie Kubernetes-Ressourcen, die Helm nicht deinstalliert.
```
kubectl delete serviceaccounts, roles, rolebindings -l emr-containers.amazonaws.com/component=flink.operator --namespace
kubectl delete crd flinkdeployments.flink.apache.org flinksessionjobs.flink.apache.org
```
1. (Optional) Löschen Sie den Cert-Manager.
```
kubectl delete -f https://github.com/jetstack/cert-manager/releases/download/v1.12.0/cert-manager.yaml
```