Messaging mit Spring Integration und Google Cloud Pub/Sub

1. Übersicht

Spring Integration bietet Ihnen einen Messaging-Mechanismus, mit dem Sie Messages bis MessageChannels austauschen können. Die Kommunikation mit externen Systemen erfolgt über Kanaladapter.

In dieser Übung erstellen wir zwei Anwendungen, die über die Spring Integration-Channeladapter von Spring Cloud GCP kommunizieren. Diese Adapter sorgen dafür, dass Spring Integration Google Cloud Pub/Sub als Back-End für den Nachrichtenaustausch verwendet.

Außerdem lernen Sie, wie Sie Cloud Shell und den Cloud SDK-Befehl "gcloud" verwenden.

In dieser Anleitung wird der Beispielcode aus dem Startleitfaden für Spring Boot verwendet.

Aufgaben in diesem Lab

• Wie Sie mithilfe von Spring Integration und Spring Cloud GCP Nachrichten zwischen Anwendungen mit Google Cloud Pub/Sub austauschen

Voraussetzungen

• Google Cloud Platform-Projekt
• Browser, z. B. Chrome oder Firefox
• Erfahrung mit standardmäßigen Linux-Texteditoren wie vim, EMAC oder Nano

Wie möchten Sie diese Anleitung nutzen?

<ph type="x-smartling-placeholder"></ph> Nur bis zum Ende lesen Lies sie dir durch und absolviere die Übungen

Wie würden Sie Ihre Erfahrung mit der Erstellung von HTML/CSS-Web-Apps bewerten?

<ph type="x-smartling-placeholder"></ph> Neuling Leicht fortgeschritten Kompetent

Wie würden Sie Ihre Erfahrungen im Umgang mit Google Cloud Platform-Diensten bewerten?

<ph type="x-smartling-placeholder"></ph> Neuling Leicht fortgeschritten Kompetent

2. Einrichtung und Anforderungen

Umgebung für das selbstbestimmte Lernen einrichten

1. Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

• Der Projektname ist der Anzeigename für die Projektteilnehmer. Es handelt sich um eine Zeichenfolge, die von Google APIs nicht verwendet wird. Sie können sie jederzeit aktualisieren.
• Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich. Sie kann nach dem Festlegen nicht mehr geändert werden. Die Cloud Console generiert automatisch einen eindeutigen String. ist Ihnen meist egal, was es ist. In den meisten Codelabs musst du auf deine Projekt-ID verweisen, die üblicherweise als PROJECT_ID bezeichnet wird. Wenn Ihnen die generierte ID nicht gefällt, können Sie eine weitere zufällige ID generieren. Alternativ können Sie einen eigenen verwenden und nachsehen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts erhalten.
• Zur Information gibt es noch einen dritten Wert, die Projektnummer, die von manchen APIs verwendet wird. Weitere Informationen zu allen drei Werten finden Sie in der Dokumentation.

Achtung:Eine Projekt-ID ist global eindeutig und kann von niemandem verwendet werden, nachdem Sie sie ausgewählt haben. Sie sind der einzige Nutzer dieser ID. Auch wenn ein Projekt gelöscht wurde, kann die ID nicht noch einmal verwendet werden

Hinweis:Wenn Sie ein Gmail-Konto verwenden, können Sie die Standardeinstellung Keine Organisation beibehalten. Wenn Sie ein Google Workspace-Konto verwenden, wählen Sie einen Standort aus, der für Ihre Organisation sinnvoll ist.

2. Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Cloud-Ressourcen/APIs verwenden zu können. Dieses Codelab ist kostengünstig. Sie können die von Ihnen erstellten Ressourcen oder das Projekt löschen, um Ressourcen herunterzufahren, um zu vermeiden, dass über diese Anleitung hinaus Kosten anfallen. Neue Google Cloud-Nutzer haben Anspruch auf das kostenlose Testprogramm mit 300$Guthaben.

Google Cloud Shell

Sie können Google Cloud zwar von Ihrem Laptop aus aus der Ferne bedienen, in diesem Codelab verwenden wir jedoch Google Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Cloud Shell aktivieren

1. Klicken Sie in der Cloud Console auf Cloud Shell aktivieren .

Wenn Sie Cloud Shell zum ersten Mal starten, wird ein Zwischenbildschirm mit einer Beschreibung der Funktion angezeigt. Wenn ein Zwischenbildschirm angezeigt wird, klicken Sie auf Weiter.

Die Bereitstellung und Verbindung mit Cloud Shell dauert nur einen Moment.

Diese virtuelle Maschine verfügt über alle erforderlichen Entwicklertools. Es bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und wird in Google Cloud ausgeführt, wodurch die Netzwerkleistung und Authentifizierung erheblich verbessert werden. Viele, wenn nicht sogar alle Arbeiten in diesem Codelab können mit einem Browser erledigt werden.

Sobald Sie mit Cloud Shell verbunden sind, sollten Sie sehen, dass Sie authentifiziert sind und das Projekt auf Ihre Projekt-ID eingestellt ist.

2. Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Sie authentifiziert sind:

gcloud auth list

Befehlsausgabe

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Hinweis: Das gcloud-Befehlszeilentool ist ein leistungsstarkes und einheitliches Befehlszeilentool in Google Cloud. Es ist in Cloud Shell vorinstalliert. Sie werden feststellen, dass die Tab-Vervollständigung unterstützt wird. Weitere Informationen finden Sie in der Übersicht zum gcloud-Befehlszeilentool.

3. Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob der gcloud-Befehl Ihr Projekt kennt:

gcloud config list project

Befehlsausgabe

[core]
project = <PROJECT_ID>

Ist dies nicht der Fall, können Sie die Einstellung mit diesem Befehl vornehmen:

gcloud config set project <PROJECT_ID>

Befehlsausgabe

Updated property [core/project].

Hinweis:Wenn Sie diese Anleitung außerhalb von Cloud Shell durcharbeiten, folgen Sie der Anleitung unter Standardanmeldedaten für Anwendungen einrichten.

3. Pub/Sub-Ressourcen bereitstellen

Rufen Sie die Google Cloud Pub/Sub-Themenseite auf.

Klicken Sie auf Thema erstellen.

Geben Sie exampleTopic als Namen des Themas ein und klicken Sie dann auf Erstellen.

Bleiben Sie nach dem Erstellen des Themas auf der Themenseite. Suchen Sie nach dem Thema, das Sie gerade erstellt haben, tippen Sie auf die drei vertikalen Punkte am Ende der Zeile und klicken Sie auf Neues Abo.

Geben Sie exampleSubscription in das Textfeld für den Abonamen ein und klicken Sie auf Erstellen.

Alternativ können Sie auch die gcloud-Befehlszeile verwenden, um ein neues Thema und Abo zu erstellen. Beispiel:

$ gcloud pubsub topics create exampleTopic

$ gcloud pubsub subscriptions create exampleSubscription --topic exampleTopic

4. Spring Boot-Anwendungen initialisieren

Nach dem Start von Cloud Shell können Sie die Befehlszeile verwenden, um mit Spring Initializr zwei neue Spring Boot-Anwendungen zu generieren:

$ curl https://start.spring.io/starter.tgz \
  -d bootVersion=3.0.5 \
  -d dependencies=web,integration,cloud-gcp-pubsub \
  -d type=maven-project \
  -d baseDir=spring-integration-sender | tar -xzvf -

$ curl https://start.spring.io/starter.tgz \
  -d bootVersion=3.0.5 \
  -d dependencies=web,integration,cloud-gcp-pubsub \
  -d type=maven-project \
  -d baseDir=spring-integration-receiver | tar -xzvf -

5. Anwendung zum Senden von Nachrichten erstellen

Erstellen wir nun unsere App zum Senden von Nachrichten. Wechseln Sie in das Verzeichnis der sendenden App.

$ cd spring-integration-sender

Wir möchten, dass unsere App Nachrichten an einen Kanal schreibt. Sobald sich eine Nachricht im Kanal befindet, wird sie vom Adapter für ausgehenden Traffic aufgenommen, der sie von einer generischen Spring-Nachricht in eine Google Cloud Pub/Sub-Nachricht konvertiert und in einem Google Cloud Pub/Sub-Thema veröffentlicht.

Damit unsere App in einen Kanal schreiben kann, können wir ein Spring Integration-Messaging-Gateway verwenden. Mit einem Texteditor aus vim, emacs oder nano deklarieren Sie eine PubsubOutboundGateway-Schnittstelle innerhalb der Klasse DemoApplication.

src/main/java/com/example/demo/DemoApplication.java

...
import org.springframework.integration.annotation.MessagingGateway;

@SpringBootApplication
public class DemoApplication {

  ...

  @MessagingGateway(defaultRequestChannel = "pubsubOutputChannel")
  public interface PubsubOutboundGateway {
    void sendToPubsub(String text);
  }
}

Wir haben jetzt einen Mechanismus, Nachrichten an einen Kanal zu senden. Aber wo werden diese Nachrichten gespeichert, nachdem sie auf dem Kanal zu finden sind?

Wir benötigen einen Ausgangskanaladapter, um neue Nachrichten im Kanal zu verarbeiten und in einem Google Cloud Pub/Sub-Thema zu veröffentlichen.

src/main/java/com/example/demo/DemoApplication.java

...
import com.google.cloud.spring.pubsub.core.PubSubTemplate;
import com.google.cloud.spring.pubsub.integration.outbound.PubSubMessageHandler;

import org.springframework.context.annotation.Bean;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.messaging.MessageHandler;

@SpringBootApplication
public class DemoApplication {

  ...

  @Bean
  @ServiceActivator(inputChannel = "pubsubOutputChannel")
  public MessageHandler messageSender(PubSubTemplate pubsubTemplate) {
    return new PubSubMessageHandler(pubsubTemplate, "exampleTopic");
  }
}

Die Anmerkung @ServiceActivator bewirkt, dass MessageHandler auf alle neuen Nachrichten in inputChannel angewendet wird. In diesem Fall rufen wir unseren Adapter für ausgehenden Kanal (PubSubMessageHandler) auf, um die Nachricht im Thema exampleTopic von Google Cloud Pub/Sub zu veröffentlichen.

Wenn der Kanaladapter eingerichtet ist, können wir jetzt ein PubsubOutboundGateway-Objekt automatisch verbinden und eine Nachricht an einen Kanal schreiben.

src/main/java/com/example/demo/DemoApplication.java

...
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.view.RedirectView;

@SpringBootApplication
public class DemoApplication {

  ...

  @Autowired
  private PubsubOutboundGateway messagingGateway;

  @PostMapping("/postMessage")
  public RedirectView postMessage(@RequestParam("message") String message) {
    this.messagingGateway.sendToPubsub(message);
    return new RedirectView("/");
  }
}

Dank der Annotation @PostMapping haben wir jetzt einen Endpunkt, der HTTP-POST-Anfragen überwacht. Es wird jedoch nicht ohne zusätzlich eine @RestController-Annotation zur DemoApplication-Klasse hinzugefügt, um sie als REST-Controller zu markieren.

src/main/java/com/example/demo/DemoApplication.java

import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {
  ...
}

Prüfen Sie, ob JAVA_HOME auf die richtige Version eingestellt ist.

export JAVA_HOME=/usr/lib/jvm/java-1.17.0-openjdk-amd64

Führen Sie die Absender-App aus.

# Set the Project ID in environmental variable
$ export GOOGLE_CLOUD_PROJECT=`gcloud config list --format 'value(core.project)'`

$ ./mvnw spring-boot:run

Die Anwendung hört POST-Anfragen mit einer Nachricht an Port 8080 und am Endpunkt /postMessage ab. Dazu kommen wir später.

6. Anwendung zum Empfangen von Nachrichten erstellen

Wir haben gerade eine App erstellt, die Nachrichten über Google Cloud Pub/Sub sendet. Jetzt erstellen wir eine weitere App, die diese Nachrichten empfängt und verarbeitet.

Klicken Sie auf +, um eine neue Cloud Shell-Sitzung zu öffnen.

Wechseln Sie dann in der neuen Cloud Shell-Sitzung zum Verzeichnis der Empfänger-App:

$ cd spring-integration-receiver

In der vorherigen App wurde der ausgehende Kanal durch die Deklaration des Messaging-Gateways erstellt. Da wir zum Empfangen von Nachrichten kein Messaging-Gateway verwenden, müssen wir unsere eigene MessageChannel deklarieren, bei der eingehende Nachrichten ankommen.

src/main/java/com/example/demo/DemoApplication.java

...
import org.springframework.context.annotation.Bean;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.messaging.MessageChannel;

@SpringBootApplication
public class DemoApplication {

  ...

  @Bean
  public MessageChannel pubsubInputChannel() {
    return new DirectChannel();
  }
}

Wir benötigen den Kanaladapter für eingehende Nachrichten, um Nachrichten von Google Cloud Pub/Sub zu empfangen und an pubsubInputChannel weiterzuleiten.

src/main/java/com/example/demo/DemoApplication.java

...
import com.google.cloud.spring.pubsub.core.PubSubTemplate;
import com.google.cloud.spring.pubsub.integration.inbound.PubSubInboundChannelAdapter;

import org.springframework.beans.factory.annotation.Qualifier;

@SpringBootApplication
public class DemoApplication {

  ...

  @Bean
  public PubSubInboundChannelAdapter messageChannelAdapter(
      @Qualifier("pubsubInputChannel") MessageChannel inputChannel,
      PubSubTemplate pubSubTemplate) {
    PubSubInboundChannelAdapter adapter =
        new PubSubInboundChannelAdapter(pubSubTemplate, "exampleSubscription");
    adapter.setOutputChannel(inputChannel);

    return adapter;
  }
}

Dieser Adapter bindet sich an pubsubInputChannel und hört neue Nachrichten aus dem exampleSubscription-Abo von Google Cloud Pub/Sub ab.

Wir haben einen Kanal, auf dem eingehende Nachrichten gepostet werden. Was soll mit diesen Nachrichten geschehen?

Wir verarbeiten sie mit einem @ServiceActivator, der ausgelöst wird, wenn neue Nachrichten unter pubsubInputChannel eingehen. In diesem Fall protokollieren wir nur die Nachrichtennutzlast.

src/main/java/com/example/demo/DemoApplication.java

...
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.integration.annotation.ServiceActivator;

@SpringBootApplication
public class DemoApplication {

  ...

  private static final Log LOGGER = LogFactory.getLog(DemoApplication.class);

  @ServiceActivator(inputChannel = "pubsubInputChannel")
  public void messageReceiver(String payload) {
    LOGGER.info("Message arrived! Payload: " + payload);
  }
}

Prüfen Sie, ob JAVA_HOME auf die richtige Version eingestellt ist.

export JAVA_HOME=/usr/lib/jvm/java-1.17.0-openjdk-amd64

Führen Sie die Empfänger-App aus.

$ ./mvnw spring-boot:run -Dspring-boot.run.jvmArguments="-Dserver.port=8081"

Jetzt werden alle Nachrichten, die Sie an die Absender-App senden, in der Empfänger-App protokolliert. Öffnen Sie dazu eine neue Cloud Shell-Sitzung und senden Sie eine HTTP-POST-Anfrage an die Absender-App.

$ curl --data "message=Hello world!" localhost:8080/postMessage

Prüfen Sie dann, ob die Empfänger-App die von Ihnen gesendete Nachricht protokolliert hat.

INFO: Message arrived! Payload: Hello world!

7. Bereinigen

Löschen Sie das Abo und das Thema, das im Rahmen dieser Übung erstellt wurde.

$ gcloud pubsub subscriptions delete exampleSubscription
$ gcloud pubsub topics delete exampleTopic

8. Zusammenfassung

Sie richten zwei Spring Boot-Anwendungen ein, die die Spring Integration-Channeladapter für Google Cloud Pub/Sub verwenden. Sie tauschen Nachrichten unter sich aus, ohne jemals mit der Google Cloud Pub/Sub API zu interagieren.

9. Glückwunsch!

Sie haben gelernt, wie Sie die Spring Integration Channel Adapter für Google Cloud Pub/Sub verwenden.

Weitere Informationen

• Google Cloud Pub/Sub: https://cloud.google.com/pubsub/
• Spring on GCP-Projekt: http://cloud.spring.io/spring-cloud-gcp/
• GitHub-Repository von Spring auf GCP: https://github.com/GoogleCloudPlatform/spring-cloud-gcp
• Java auf der Google Cloud Platform: https://cloud.google.com/java/

Lizenz

Dieser Text ist mit einer Creative Commons Attribution 2.0 Generic License lizenziert.