Diese Seite wurde von der Cloud Translation API übersetzt.

Weitere Informationen finden Sie unter Unterstützte Connectors für Application Integration.

CRUD-Vorgänge in einer MySQL-Datenbank ausführen

In dieser Anleitung erfahren Sie, wie Sie eine Verbindung zu einer MySQL-Datenbankinstanz anhand einer Beispielintegration herstellen sowie die Vorgänge „Auflisten“, „Abrufen“, „Erstellen“, „Aktualisieren“ und „Löschen“ in einer MySQL-Datenbanktabelle ausführen.

Hinweise

Prüfen Sie, ob Sie Zugriff auf Application Integration haben.
Wählen Sie das Google Cloud-Projekt aus und führen Sie die folgenden Aufgaben aus:
- Weisen Sie dem Dienstkonto, das Sie zum Erstellen der Verbindung verwenden möchten, die folgenden Rollen zu:
  - roles/secretmanager.viewer
  - roles/secretmanager.secretAccessor
- Aktivieren Sie die folgenden Dienste:
  - secretmanager.googleapis.com (Secret Manager API)
  - connectors.googleapis.com (Connectors API)
  Wenn diese Dienste zuvor noch nicht für Ihr Projekt aktiviert wurden, werden Sie beim Erstellen der Verbindung aufgefordert, sie zu aktivieren.
Prüfen Sie, ob Sie Zugriff auf einen MySQL-Server haben, mit dem Sie eine Datenbank erstellen können. Eine Liste aller unterstützten Connectors und Versionen finden Sie unter Connector-Referenz

Datenbank und Tabelle in MySQL erstellen

Führen Sie die folgenden Befehle auf einem System aus, auf dem ein MySQL-Client installiert ist:

Stellen Sie eine Verbindung zu Ihrem MySQL-Server her:
```
mysql --host=MYSQL_HOSTNAME_OR_IP_ADDRESS --port=PORT_NUMBER -uUSERNAME -pPASSWORD
```
Ersetzen Sie Folgendes:
- MYSQL_HOSTNAME_OR_IP_ADDRESS: der Name oder die IP-Adresse des MySQL-Servers.
- PORT_NUMBER: die Portnummer für den MySQL-Server.
- USERNAME: der Nutzername für den MySQL-Server.
- PASSWORD: das Passwort des Nutzers für Ihren MySQL-Server.
Eine MySQL-Datenbank erstellen:
```
CREATE DATABASE tutorialDB;
```

Eine Tabelle erstellen:

CREATE TABLE EMPLOYEE
  (
  employee_id int auto_increment primary key,
  employee_first_name varchar(500) NOT null,
  employee_last_name varchar(500) NOT null,
  employee_emailID varchar(500)
  );

Fügen Sie der von Ihnen erstellten Tabelle EMPLOYEE Zeilen hinzu:

INSERT INTO EMPLOYEE (employee_first_name,employee_last_name,employee_emailID) values ("Peter","Dilliard","test-01@test.com");
INSERT INTO EMPLOYEE (employee_first_name,employee_last_name,employee_emailID) values ("Meaghan","Webb","test-02@test.com");

Prüfen Sie, ob die Tabelle erstellt und Zeilen hinzugefügt wurden:

SELECT * FROM EMPLOYEE;

Die folgenden Tabellenzeilen werden angezeigt:

+-------------+---------------------+--------------------+------------------+
| employee_id | employee_first_name | employee_last_name | employee_emailID |
+-------------+---------------------+--------------------+------------------+
|           1 | Peter               | Dilliard           | test-01@test.com |
|           2 | Meaghan             | Webb               | test-02@test.com |
+-------------+---------------------+--------------------+------------------+

MySQL-Verbindung erstellen

Damit eine Integration eine Verbindung zu Ihrer MySQL-Datenbank herstellen kann, erstellen Sie eine neue Verbindung zu Ihrer MySQL-Datenbank.

Klicken Sie auf + neu erstellen, um die Seite Verbindung erstellen zu öffnen.
Wählen Sie im Abschnitt Standort den Standort für die Verbindung aus.
1. Wählen Sie in der Liste Region die Region aus, in der Sie die Verbindung erstellen möchten.
  Eine Liste aller unterstützten Regionen finden Sie unter Standorte.
2. Klicken Sie auf Next (Weiter).
Geben Sie im Abschnitt Verbindungsdetails die folgenden Details ein:
1. Wählen Sie aus der Connector-Liste MySQL (Vorabversion) aus.
2. Wählen Sie aus der Liste Connector-Version die Connector-Version aus.
3. Geben Sie im Feld Verbindungsname einen Namen für die Verbindungsinstanz ein.
  Verbindungsnamen müssen die folgenden Kriterien erfüllen:
  - Verwenden Sie Buchstaben, Ziffern oder Bindestriche.
  - Buchstaben müssen Kleinbuchstaben sein.
  - Namen müssen mit einem Buchstaben beginnen und mit einem Buchstaben oder einer Ziffer enden.
  - Namen dürfen maximal 63 Zeichen haben.
4. Optional: Geben Sie im Feld Beschreibung eine Beschreibung der Verbindungsinstanz ein.
5. Optional: Aktivieren Sie Cloud Logging.
6. Wählen Sie in der Liste Dienstkonto ein Dienstkonto mit den erforderlichen Rollen aus.
7. Geben Sie im Feld Datenbankname den Namen der MySQL-Datenbank ein.
8. Konfigurieren Sie optional die Einstellungen für den Verbindungsknoten:
  - Mindestanzahl von Knoten: Geben Sie die Mindestanzahl von Verbindungsknoten ein.
  - Maximale Anzahl von Knoten: Geben Sie die maximale Anzahl von Verbindungsknoten ein.
  Ein Knoten ist eine Einheit (oder ein Replikat) einer Verbindung, die Transaktionen verarbeitet. Zur Verarbeitung von mehr Transaktionen für eine Verbindung sind mehr Knoten erforderlich. Umgekehrt sind weniger Knoten erforderlich, um weniger Transaktionen zu verarbeiten. Informationen zu den Auswirkungen der Knoten auf Ihre Connector-Preise finden Sie unter Preise für Verbindungsknoten. Wenn Sie keine Werte eingeben, ist die Mindestanzahl von Knoten standardmäßig auf 2 (für eine bessere Verfügbarkeit) und die maximale Knotenzahl auf 50 gesetzt.
9. Proxy verwenden: Klicken Sie dieses Kästchen an, um einen Proxyserver für die Verbindung und konfigurieren Sie die folgenden Werte:
10. Optional: Klicken Sie auf + Label hinzufügen, um der Verbindung ein Label hinzuzufügen.
11. Klicken Sie auf Next (Weiter).
12. Geben Sie im Abschnitt Ziele Details zum Remote-Host (Back-End-System) ein, die Sie verbinden möchten.
  - Wählen Sie aus der Liste Zieltyp eine Hostadresse aus.
    - Wählen Sie in der Liste Hostadresse aus, um den Hostnamen oder die IP-Adresse des Ziels anzugeben.
    - Wenn Sie eine private Verbindung zu Ihren Backend-Systemen herstellen möchten, wählen Sie in der Liste Endpunktanhang und dann den erforderlichen Endpunktanhang aus der Liste Endpunktanhang aus.
      Hinweis : Informationen zum Erstellen eines Endpunktanhangs finden Sie unter PSC-Dienstanhang und Endpunktanhang. Nachdem Sie den Endpunktanhang erstellt haben, wird er in der Liste Endpunktanhang angezeigt.
    Wenn Sie eine öffentliche Verbindung zu Ihren Back-End-Systemen mit zusätzlicher Sicherheit herstellen möchten, können Sie statische ausgehende IP-Adressen für Ihre Verbindungen konfigurieren und dann Ihre Firewallregeln konfigurieren, um nur bestimmte statische IP-Adressen zuzulassen.
    
    Wenn Sie weitere Ziele eingeben möchten, klicken Sie auf + Ziel hinzufügen.
  - Klicken Sie auf Next (Weiter).
13. Im Abschnitt Authentication (Authentifizierung) können Sie Anmeldedaten angeben:
  - Geben Sie im Feld Nutzername den MySQL-Nutzernamen für die Verbindung ein.
  - Geben Sie im Feld Passwort das Secret Secret Manager mit dem Passwort ein, das dem MySQL-Nutzernamen zugeordnet ist.
    - Wenn Sie bereits ein Secret erstellt haben und es nicht in der Liste verfügbar ist, wählen Sie Secret manuell eingeben aus. Kopieren Sie im Dialogfeld Secret nach Ressourcen-ID hinzufügen die Ressourcen-ID aus dem Secret Manager und fügen Sie sie ein.
      - Um die neueste Version zu verwenden, kopieren Sie die Ressourcen-ID aus dem übergeordneten Secret im Format "projects/project-number/secrets/secret-name" und fügen Sie sie ein.
      - Wenn Sie eine bestimmte Version auswählen möchten, kopieren Sie die Ressourcen-ID für diese Version im Format "projects/project-number/secrets/secret-name/versions/1" und fügen Sie sie ein.
      Klicken Sie auf Secret hinzufügen, um das Secret hinzuzufügen.
    - Wenn Sie kein Secret für die Verwendung mit MySQL erstellt haben, klicken Sie auf Erstellen Neues Secret. Geben Sie im Dialogfeld Secret erstellen die folgenden Details ein:
      - Geben Sie im Feld Name den folgenden Namen ein.
      - Geben Sie im Feld Secret-Wert den Inhalt des Secrets ein oder laden Sie eine Datei hoch, die das Secret enthält.
      - Klicken Sie auf Secret erstellen.
  - Wählen Sie aus der Liste Secret-Version die Version des Passwort-Secrets aus der Liste der verfügbaren Versionen im Drop-down-Menü aus.
  - Klicken Sie auf Next (Weiter).
Prüfen Sie im Abschnitt Überprüfen Ihre Verbindungs- und Authentifizierungsdetails.
Klicken Sie auf Erstellen.

Authentifizierung konfigurieren

Geben Sie die Details basierend auf der zu verwendenden Authentifizierung ein.

Nutzername und Passwort
- Nutzername: Der Mysql-Nutzername für die Verbindung.
- Kennwort: Secret Manager-Secret mit dem Passwort, das dem Mysql-Nutzernamen zugeordnet ist.

Integration zur Verwendung der MySQL-Verbindung konfigurieren

Um die MySQL-Verbindung zu verwenden, die Sie in einer Integration erstellt haben, müssen Sie die folgenden Aufgaben ausführen:

Neue Integration erstellen
API-Trigger hinzufügen und konfigurieren
Connectors-Aufgabe hinzufügen und konfigurieren
API-Trigger-Element mit dem Connectors-Aufgabenelement verbinden

Neue Integration erstellen

Rufen Sie in der Google Cloud Console die Seite Application Integration auf.
Zu Application Integration
Klicken Sie im Navigationsmenü auf Integrationen. Die Seite Integrations List (Integrationsliste) wird angezeigt.
Klicken Sie auf Integration erstellen.
Geben Sie im Feld Name der Integration einen Namen für die Integration ein.

Optional: Geben Sie im Feld Beschreibung eine Beschreibung ein.
Wählen Sie in der Liste Region eine Region für die Integration aus. In der Liste Regionen werden nur die in Ihrem Google Cloud-Projekt bereitgestellten Regionen aufgeführt. Klicken Sie zum Bereitstellen einer neuen Region auf Region aktivieren. Informationen zum Bereitstellen neuer Regionen finden Sie unter Neue Region aktivieren.
Klicken Sie auf Erstellen, um den Integrationseditor zu öffnen.

API-Trigger hinzufügen und konfigurieren

Nachdem Sie eine neue Integration erstellt haben, können Sie einen API-Trigger hinzufügen und konfigurieren. Führen Sie dazu die folgenden Schritte aus:

Klicken Sie in der Symbolleiste des Integrationseditors auf Trigger, um eine Liste der verfügbaren Trigger aufzurufen.
Ziehen Sie das API-Element in den Integrationseditor.

Connectors-Aufgabe hinzufügen und konfigurieren

So konfigurieren Sie eine Connectors-Aufgabe, mit der alle Entitäten in der Tabelle employee aufgelistet werden: führen Sie folgende Schritte aus:

Klicken Sie in der Symbolleiste des Integrationseditors auf Tasks (Aufgaben), um die Liste der verfügbaren Aufgaben aufzurufen.
Ziehen Sie das Element Connectors in den Integrationseditor.
Klicken Sie im Designer auf das Aufgabenelement Connectors, um das Steuerfeld Connectors zu öffnen.
Klicken Sie im Bereich Connectors auf Connector konfigurieren.
Führen Sie im Dialogfeld Connector-Task-Editor die folgenden Schritte aus:
1. Wählen Sie in der Liste Region die Verbindungsregion aus, in der Sie die MySQL-Verbindung erstellt haben.
2. Wählen Sie aus der Liste Verbindung die von Ihnen erstellte MySQL-Verbindung aus und klicken Sie auf Weiter.
3. Wählen Sie im Abschnitt Type (Typ) die Option Entities (Entitäten) aus und klicken Sie dann auf Next (Weiter).
4. Wählen Sie aus der Liste Entität den Mitarbeiter aus.
5. Wählen Sie in der Liste Vorgang die Option Liste aus und klicken Sie auf Weiter.
6. Klicken Sie auf Fertig, um die Verbindungskonfiguration abzuschließen und das Dialogfeld zu schließen.

API-Trigger-Element mit dem Connectors-Aufgabenelement verbinden

Fügen Sie dann eine Edge-Verbindung hinzu, um den API-Trigger mit der Connectors-Aufgabe zu verbinden. Eine Edge-Verbindung ist eine Verbindung zwischen zwei Elementen in einer Integration. Informationen zu Kanten und Randbedingungen finden Sie unter Kanten.

So fügen Sie die Edge-Verbindung hinzu:

Klicken Sie unten im API-Triggerelement auf den Kontrollpunkt Fork.
Ziehen Sie die Edge-Verbindung am Steuerpunkt Join per Drag-and-drop an den oberen Rand des Connectors-Aufgabenelements.

Integration testen

So testen Sie die Integration:

Klicken Sie in der Symbolleiste des Integrationseditors auf Test.
Optional: Ändern Sie den Wert unter Ausführungsfrist (in Minuten) und klicken Sie auf Integration testen.
Nachdem die Integration erfolgreich abgeschlossen wurde, wird im Bereich Integration testen die Meldung Integration erfolgreich ausgeführt angezeigt. Klicken Sie zum Ansehen der Logs auf Logs ansehen.

Erweitern Sie den Abschnitt Antwortparameter. Unter Nutzlast der Connector-Ausgabe wird die folgende Ausgabe angezeigt:

[ {
    "employee_id": 1.0,
    "employee_first_name": "Peter",
    "employee_last_name": "Dilliard",
    "employee_emailID": "test-01@test.com"
  },
  {
    "employee_id": 2.0,
    "employee_first_name": "Meaghan",
    "employee_last_name": "Webb",
    "employee_emailID": "test-02@test.com"
  } ]

Weitere Vorgänge für die MySQL-Datenbanktabelle ausführen

Wenn Sie eine Connectors-Aufgabe in der Integration konfigurieren, können Sie einen der folgenden Vorgänge auswählen:

Liste
Get
Erstellen
Aktualisieren
Löschen

Sie haben den Vorgang „Auflisten“ bereits verwendet, um alle Zeilen in der Tabelle employee anzusehen. In den folgenden Abschnitten dieser Anleitung verwenden Sie die Vorgänge „Abrufen“, „Erstellen“, „Aktualisieren“ und „Löschen“, um Zeilen aus der Tabelle employee hinzuzufügen, zu ändern oder zu entfernen.

Zeile aus einer Tabelle abrufen

Wenn Sie die Entitäts-ID (oder den Primärschlüssel) der Zeile kennen, die Sie abrufen möchten, geben Sie diesen Wert als Eingabe für einen Vorgang „Abrufen“ in Ihrer Integration an. Die vom Vorgang „Abrufen“ zurückgegebenen Details ähneln den vom Vorgang „Auflisten“ zurückgegebenen Details. Der Vorgang „Auflisten“ ruft Details aller Tabellenzeilen ab, die mit der angegebenen Abfrage übereinstimmen. Der Vorgang „Abrufen“ hingegen ruft nur die Details aus der Tabellenzeile ab, die mit der angegebenen Entitäts-ID übereinstimmt.

Beachten Sie, dass der Vorgang „Auflisten“ standardmäßig alle Zeilen in der Tabelle zurückgibt, der Vorgang „Abrufen“ jedoch eine Entitäts-ID als Suchparameter erfordert. Für die Verwendung des Vorgangs „Abrufen“ müssen Sie daher die Entitäts-ID der abzurufenden Zeile kennen oder einen Standardwert für die Entitäts-ID angeben.

Wenn Sie Details zu einer bestimmten Zeile abrufen möchten, führen Sie die folgenden Schritte aus, um die zuvor erstellte Connectors-Aufgabe zu konfigurieren:

Klicken Sie im Integrationseditor auf das Aufgabenelement für Connectors, um den Konfigurationsbereich Connectors aufzurufen.
Klicken Sie im Konfigurationsbereich Connectors auf Connector konfigurieren. Führen Sie im Dialogfeld Connector-Task-Editor die folgenden Schritte aus:
1. Wählen Sie im Abschnitt Set entities/action (Entitäten/Aktion festlegen) aus der Liste Operations (Vorgänge) die Option Get (Abrufen) aus.
2. Klicken Sie auf Fertig.
Maximieren Sie im Konfigurationsbereich Connectors den Abschnitt Aufgabeneingabe. Führen Sie anschließend folgende Schritte aus:
1. Klicken Sie auf die Entitäts-ID.
2. Wählen Sie im angezeigten Dialogfeld Variable bearbeiten die Option Eingabe in Integration aus.
3. Klicken Sie auf Speichern
Klicken Sie in der Symbolleiste des Integrationseditors auf Test.
Optional: Ändern Sie den Wert unter Ausführungsfrist (in Minuten).
Geben Sie die Entitäts-ID der Entität ein, zur der Sie Details abrufen möchten. Beispiel: 2.
Klicken Sie auf Integration testen.
Nachdem die Integration erfolgreich abgeschlossen wurde, wird im Bereich Integration testen die Meldung Integration erfolgreich ausgeführt angezeigt. Klicken Sie zum Ansehen der Logs auf Logs ansehen.

Erweitern Sie den Abschnitt Antwortparameter. Unter Nutzlast der Connector-Ausgabe wird die folgende Ausgabe angezeigt:

[ {
    "employee_id": 2.0,
    "employee_first_name": "Meaghan",
    "employee_last_name": "Webb",
    "employee_emailID": "test-02@test.com"
  } ]

Sie können prüfen, ob die hier angezeigten Informationen mit den Informationen in der entsprechenden Zeile in der MySQL-Tabelle übereinstimmen. Führen Sie den folgenden Befehl über den MySQL-Client aus, um diese Informationen in der MySQL-Tabelle anzusehen:

SELECT * FROM employee WHERE employee_id=2;

Die folgende Tabellenzeile wird angezeigt:

+-------------+---------------------+--------------------+------------------+
| employee_id | employee_first_name | employee_last_name | employee_emailID |
+-------------+---------------------+--------------------+------------------+
|           2 | Meaghan             | Webb               | test-02@test.com |
+-------------+---------------------+--------------------+------------------+

Zeilen zu einer Tabelle hinzufügen

Mit dem Vorgang „Erstellen“ können Sie eine Zeile zu einer Tabelle hinzufügen. Wenn Sie den Vorgang „Erstellen“ verwenden, müssen Sie alle Werte für die Entität in der Connector-Eingabenutzlast angeben.

Zum Hinzufügen einer Zeile mit dem Vorgang „Erstellen“ führen Sie die folgenden Schritte aus, um die zuvor erstellte Connectors-Aufgabe zu konfigurieren.

Klicken Sie im Integrationseditor auf das Aufgabenelement für Connectors, um den Konfigurationsbereich Connectors aufzurufen.
Klicken Sie im Konfigurationsbereich Connectors auf Connector konfigurieren. Führen Sie im Dialogfeld Connector-Task-Editor die folgenden Schritte aus:
1. Wählen Sie im Abschnitt Set entities/action (Entitäten/Aktion festlegen) aus der Liste Operations (Vorgänge) die Option Create (Erstellen) aus.
2. Klicken Sie auf Fertig.
Maximieren Sie im Konfigurationsbereich Connectors den Abschnitt Aufgabeneingabe. Führen Sie anschließend folgende Schritte aus:
1. Klicken Sie auf die Entitäts-ID.
2. Wählen Sie im angezeigten Dialogfeld Variable bearbeiten die Option Eingabe in Integration aus
3. Klicken Sie auf Speichern.
Klicken Sie in der Symbolleiste des Integrationseditors auf Test.
Optional: Ändern Sie den Wert unter Ausführungsfrist (in Minuten).
Geben Sie die Details für die Entität ein, die Sie erstellen möchten. Wenn Sie beispielsweise einen neuen Mitarbeiter in die Tabelle employee einfügen möchten, geben Sie den folgenden JSON-Code ein:
```
{
  "employee_first_name": "Mary",
  "employee_last_name": "Smith",
  "employee_emailID": "test-03@test.com"
}
```
Hinweis: Geben Sie nicht den Primärschlüssel employee_id an, da es sich um einen schreibgeschützten Wert handelt, der generiert wird, wenn die Zeile zur Tabelle hinzugefügt wird.
Klicken Sie auf Integration testen.
Nachdem die Integration erfolgreich abgeschlossen wurde, wird im Bereich Integration testen die Meldung Integration erfolgreich ausgeführt angezeigt. Klicken Sie zum Ansehen der Logs auf Logs ansehen.
Erweitern Sie den Abschnitt Antwortparameter. Unter Nutzlast der Connector-Ausgabe wird die folgende Ausgabe angezeigt:
```
{
  "employee_first_name": "Mary",
  "employee_last_name": "Smith",
  "employee_emailID": "test-03@test.com"
}
```
Unter Nutzlast der Connector-Ausgabe wird die Entitäts-ID als Ausgabe angezeigt:
```
{
  "employee_id": 3.0
}
```

Sie können prüfen, ob die Zeile in die MySQL-Tabelle eingefügt wurde. Führen Sie den folgenden Befehl über den MySQL-Client aus, um diese Informationen in der MySQL-Tabelle anzusehen:

SELECT * FROM employee;

Die folgenden Tabellenzeilen werden angezeigt:

+-------------+---------------------+--------------------+------------------+
| employee_id | employee_first_name | employee_last_name | employee_emailID |
+-------------+---------------------+--------------------+------------------+
|           1 | Peter               | Dilliard           | test-01@test.com |
|           2 | Meaghan             | Webb               | test-02@test.com |
|           3 | Mary                | Smith              | test-03@test.com |
+-------------+---------------------+--------------------+------------------+

Zeilen in einer Tabelle aktualisieren

Verwenden Sie den Vorgang „Aktualisieren“, um die Werte in einer Tabellenzeile zu ändern. Mit diesem Vorgang können Sie beispielsweise die E-Mail-ID eines Mitarbeiters in der Tabelle employee aktualisieren. Zum Angeben der Entität, die Sie aktualisieren möchten, können Sie die Entitäts-ID angeben, wie auch für den Vorgang „Abrufen“. Alternativ können Sie den Parameter Filterklausel verwenden, um Werte zu übergeben, nach denen die Tabellenzeilen gefiltert werden. Dies ist nützlich, wenn Sie die gleiche Änderung basierend auf bestimmten Suchkriterien in mehreren Zeilen vornehmen möchten.

Führen Sie die folgenden Schritte aus, um die zuvor erstellte Connectors-Aufgabe zu konfigurieren:

Klicken Sie im Integrationseditor auf das Aufgabenelement für Connectors, um den Konfigurationsbereich Connectors aufzurufen.
Klicken Sie im Konfigurationsbereich Connectors auf Connector konfigurieren. Führen Sie im Dialogfeld Connector-Task-Editor die folgenden Schritte aus:
1. Wählen Sie im Abschnitt Entitäten/Aktionen festlegen in der Liste Vorgänge die Option Aktualisieren aus.
2. Klicken Sie auf Fertig.
Maximieren Sie im Konfigurationsbereich Connectors den Abschnitt Aufgabeneingabe. Führen Sie anschließend folgende Schritte aus:
1. Klicken Sie auf Filterklausel.
2. Wählen Sie im angezeigten Dialogfeld Variable bearbeiten die Option Eingabe in Integration aus
3. Klicken Sie auf Speichern.
Klicken Sie in der Symbolleiste des Integrationseditors auf Test.
Optional: Ändern Sie den Wert unter Ausführungsfrist (in Minuten).
Geben Sie die Kriterien ein, nach denen Sie filtern möchten. Wenn Sie beispielsweise nach einem Mitarbeiter mit der E-Mail-ID test-03@test.com suchen möchten, geben Sie Folgendes ein:
```
employee_emailID="test-03@test.com"
```
Hinweis: Wenn mehrere Tabellenzeilen den Filterkriterien entsprechen, wird die im nächsten Schritt angegebene Aktualisierung für alle übereinstimmenden Zeilen vorgenommen.
Geben Sie die Werte ein, die Sie aktualisieren möchten. Wenn Sie beispielsweise die E-Mail-ID aller Mitarbeiter in der Tabelle employee aktualisieren möchten, deren aktuelle E-Mail-ID mit der Filterklausel test-03@test.com übereinstimmt, geben Sie den folgenden JSON-Code ein:
```
{
  "employee_emailID": "msmith@test.com"
}
```
Hinweis: Sie müssen nicht für alle Spalten in der Tabelle Werte angeben. Geben Sie die Werte ein, die Sie aktualisieren möchten. Die anderen Werte werden nicht geändert.
Klicken Sie auf Integration testen.
Nachdem die Integration erfolgreich abgeschlossen wurde, wird im Bereich Integration testen die Meldung Integration erfolgreich ausgeführt angezeigt.
Rufen Sie mit dem Vorgang „Abrufen“ die Details der angegebenen Entität ab, um zu prüfen, ob die Entität aktualisiert wurde.

Sie können prüfen, ob die Zeile in der MySQL-Tabelle aktualisiert wurde. Führen Sie den folgenden Befehl über den MySQL-Client aus, um diese Informationen in der MySQL-Tabelle anzusehen:

SELECT * FROM employee;

Die folgenden Tabellenzeilen werden angezeigt:

+-------------+---------------------+--------------------+------------------+
| employee_id | employee_first_name | employee_last_name | employee_emailID |
+-------------+---------------------+--------------------+------------------+
|           1 | Peter               | Dilliard           | test-01@test.com |
|           2 | Meaghan             | Webb               | test-02@test.com |
|           3 | Mary                | Smith              | msmith@test.com  |
+-------------+---------------------+--------------------+------------------+

Zeilen in einer Tabelle löschen

Mit dem Vorgang „Löschen“ können Sie eine oder mehrere Tabellenzeilen löschen. Geben Sie die Entitäts-ID an oder geben Sie mithilfe der Filterklausel die Zeilen an, die Sie löschen möchten. Wenn Sie die Filterklausel zum Angeben von Kriterien für die Zeilen verwenden, die Sie löschen möchten, werden möglicherweise mehrere Zeilen gelöscht, die dem angegebenen Filter entsprechen. Wenn Sie nur eine bestimmte Zeile löschen möchten, verwenden Sie die Entitäts-ID.

Zum Löschen einer Tabellenzeile mithilfe der Entitäts-ID führen Sie die folgenden Schritte aus, um die zuvor erstellte Connectors-Aufgabe zu konfigurieren:

Klicken Sie im Integrationseditor auf das Aufgabenelement „Connectors“, um den Konfigurationsbereich Connectors aufzurufen.
Klicken Sie im Konfigurationsbereich Connectors auf Connector konfigurieren. Führen Sie im Dialogfeld Connector-Task-Editor die folgenden Schritte aus:
1. Wählen Sie im Abschnitt Set entities/action (Entitäten/Aktion festlegen) aus der Liste Operations (Vorgänge) die Option Get (Abrufen) aus.
2. Klicken Sie auf Fertig.
Maximieren Sie im Konfigurationsbereich Connectors den Abschnitt Aufgabeneingabe. Führen Sie anschließend folgende Schritte aus:
1. Klicken Sie auf die Entitäts-ID.
2. Wählen Sie im angezeigten Dialogfeld Variable bearbeiten die Option Eingabe in Integration aus
3. Klicken Sie auf Speichern.
Klicken Sie in der Symbolleiste des Integrationseditors auf Test.
Optional: Ändern Sie den Wert unter Ausführungsfrist (in Minuten).
Geben Sie die Entitäts-ID der Entität ein, zur der Sie Details abrufen möchten. Beispiel: 2.
Klicken Sie auf Integration testen.
Nachdem die Integration erfolgreich abgeschlossen wurde, wird im Bereich Integration testen die Meldung Integration erfolgreich ausgeführt angezeigt.
Prüfen Sie mithilfe des Vorgangs „Abrufen“, ob die Tabellenzeile gelöscht wurde. So rufen Sie die Details der gelöschten Zeile ab. Sie sollten nun einen Fehler für die angegebene Entitäts-ID erhalten.

Sie können auch den Vorgang „Auflisten“ verwenden und optional eine Filterklausel für die Tabellenzeile (n) angeben, die Sie gelöscht haben. Daraufhin wird die Liste der verbleibenden Zeilen zurückgegeben; dies kann eine leere Liste sein.

Wenn Sie beispielsweise die Tabellenzeile mit der Entitäts-ID 3 gelöscht haben und die Filterklausel employee_emailID="msmith@test.com" oder die Entitäts-ID 3 für den Vorgang „Auflisten“ angeben, zeigen die Antwortparameter in der Loganzeige [] an.

Sie können prüfen, ob die Zeile in der MySQL-Tabelle gelöscht wurde. Führen Sie den folgenden Befehl über den MySQL-Client aus, um diese Informationen in der MySQL-Tabelle aufzurufen:

SELECT * FROM employee;

Die folgenden Tabellenzeilen werden angezeigt:

+-------------+---------------------+--------------------+------------------+
| employee_id | employee_first_name | employee_last_name | employee_emailID |
+-------------+---------------------+--------------------+------------------+
|           1 | Peter               | Dilliard           | test-01@test.com |
|           2 | Meaghan             | Webb               | test-02@test.com |
+-------------+---------------------+--------------------+------------------+

Nächste Schritte

Integrationen mit anderen Connectors erstellen. Für die Liste unterstützt. Siehe Alle Integration Connectors.