Ein Beispiel für die Verwendung von Dapr zur Vereinfachung von Microservices von Grund auf

Vorwort

Das vorhandene Microservice-Modell erfordert die Integration einer großen Anzahl von Infrastrukturmodulen in den Geschäftscode, wie z. B. Registrierungscenter, Service Discovery, Service Call Link Tracking, Request Circuit Breaking, Retry Flow Control usw., wodurch das System zu aufgebläht und schwerfällig wird.

Als Microservice-Modell einer neuen Generation verwendet Dapr das Sidecar-Modell, um den vorhandenen Microservice-Systemcode zu vereinfachen und die Infrastrukturschicht im Sidecar-Modell zu trennen, sodass sich Entwickler stärker auf das Schreiben der Geschäftslogik konzentrieren können.

Dieser Artikel erstellt ein einfaches Anwendungsbeispiel von dapr basierend auf net6 und dapr1.5.

1. Docker installieren

Der Betrieb von Dapr hängt von der Docker-Umgebung ab.

Verwenden Sie als Lernumgebung das Centos 7-System, um Docker zu installieren.

Es wird empfohlen, zum Installieren von Docker den Ein-Klick-Installationsbefehl daocloud zu verwenden:

curl -sSL https://get.daocloud.io/docker | sh

Führen Sie nach Abschluss der Installation den folgenden Befehl aus:

[root@localhost ~]# docker -v
Docker-Version 20.10.11, Build dea9396

Wird die entsprechende Docker-Version angezeigt, war die Installation erfolgreich.

2. Installieren Sie Dapr CLI

Offizielle Erklärung: Dapr CLI ist Ihr Haupttool für verschiedene Dapr-bezogene Aufgaben. Sie können es verwenden, um eine Anwendung mit einem Dapr-Sidecar auszuführen, Sidecar-Protokolle anzuzeigen, laufende Dienste aufzulisten und das Dapr-Dashboard auszuführen.

Laden Sie die Dapr-CLI herunter

wget -q https://raw.githubusercontent.com/dapr/cli/master/install/install.sh -O - | /bin/bash

Überprüfen der Installation

dapr -v

Die Installation war erfolgreich, wenn die folgende Ausgabe angezeigt wird.

CLI-Version: 1.5.0
Laufzeitversion: 1.5.0

Aufgrund inländischer Netzwerkprobleme treten bei der Verwendung der offiziellen Dapr-Installationsmethode im Allgemeinen verschiedene Probleme auf. Laden Sie daher dapr herunter und installieren Sie es über das Skript.

Ändern Sie die Hosts-Datei

vi /etc/hosts
140.82.114.4 github.com  
199.232.69.194 github.global.ssl.fastly.net
140.82.114.9 codeload.github.com

Aktualisieren Sie den Cache

yum install -y nscd
Dienst NSCD neu starten

Zuerst müssen Sie Git installieren und dann den folgenden Befehl ausführen:

git clone -v https://gitee.com/Two-Twoone/dapr-installer.git
cd dapr-installer/
./install.sh

Es ist immer noch langsam, aber immer noch besser, als überhaupt nichts herunterladen zu können.

Der obige Befehl startet mehrere Container. Führen Sie zur Überprüfung die folgenden Vorgänge aus:

[root@localhost dapr-installer]# docker ps --format "Tabelle {{.ID}}\t{{.Names}}\t{{.Ports}}"
CONTAINER ID NAMEN HAFEN
a0565f609846 dapr_placement 0.0.0.0:50005->50005/tcp, :::50005->50005/tcp
c392f5cf7a18 dapr_redis 0.0.0.0:6379->6379/tcp, :::6379->6379/tcp
2ee68c450b29 dapr_zipkin 9410/tcp, 0.0.0.0:9411->9411/tcp, :::9411->9411/tcp

3. Installieren Sie das Net6 SDK

rpm -Uvh https://packages.microsoft.com/config/rhel/7/packages-microsoft-prod.rpm
 Yum-Aktualisierung
 yum installiere dotnet-sdk-6.0

4. Erstellen Sie eine Anwendung

Erstellen Sie zwei Projekte, Produkt und Warenkorb, und verweisen Sie auf Dapr

dotnet fügt Paket Dapr.AspNetCore hinzu

Der Aufruf von AddDapr in Program.cs registriert DaprClient -Klasse beim ASP.NET Core-Injektionssystem. Nachdem der Client registriert ist, können Sie nun Instanzen von DaprClient in Ihren Dienstcode einfügen, um mit Dapr-Sidecars, -Bausteinen und -Komponenten zu kommunizieren.

builder.Services.AddControllers().AddDapr();

4.1 Service-Anruf

In einem Microservice-System sind Aufrufe zwischen Diensten von entscheidender Bedeutung. Die Schwierigkeiten konzentrieren sich hauptsächlich auf den Standort des Dienstes, den erneuten Versuch bei Auftreten eines Fehlers, den Lastausgleich und andere Probleme.

Dapr verwendet Sidecar als Reverse-Proxy-Modul für Dienste, um diese Probleme zu lösen.

Fügen Sie dem Produktprojekt den folgenden Code hinzu

[Route("API/[Controller]")]
    [ApiController]
    öffentliche Klasse ProductController: ControllerBase
    {
        privater ILogger<ProduktController> _logger;

        öffentlicher ProductController (ILogger<ProductController>-Logger)
        {
            _logger = Logger;
        }
        private statische schreibgeschützte Liste<Zeichenfolge> Produkte = neue Liste<Zeichenfolge> { "aa", "bb", "cc", "dd", "ee", "ff", "gg", "hh", "ii", "jj", "kk", "ll", "mm", "nn" };
        [HttpGet]
        öffentliches ActionResult Get()
        {
            _logger.LogInformation($"Die Methode zum Abrufen von Produkten wurde aufgerufen");
            string[] temps = neuer string[5];
            für (int i = 0; i < 5; i++)
            {
                Zufallsgenerator random = neuer Zufallsgenerator(Guid.NewGuid().GetHashCode());
                temps[i] = Produkte[random.Weiter(0, Produkte.Anzahl - 1)];
            }
            returniere Ok(temps);
        }
    }

# Starten Sie das Produktprojekt dapr run --app-id ProductDemo --app-port 5010 --dapr-http-port 7015 -- dotnet /root/www/product/Dapr.Product.Sample.dll --urls http://*:5010

Das Cart-Projekt fügt den folgenden Code hinzu. dapr unterstützt HTTP- und GRPC-Aufrufmethoden. Hier nehmen wir die häufig verwendete WebAPI als Beispiel und verwenden HTTP zum Aufrufen.

Die App-ID in der Methode InvokeMethodAsync entspricht der App-ID im Dapr-Ausführungsvorgang, unabhängig von der aufrufenden Adresse.

[Route("API/[Controller]")]
    [ApiController]
    öffentliche Klasse CartController: ControllerBase
    {
        privater schreibgeschützter DaprClient _daprClient;
        privater schreibgeschützter ILogger<CartController> _logger;
        öffentlicher CartController (DaprClient daprClient, ILogger<CartController> logger)
        {
            _daprClient = daprClient;
            _logger = Logger;
        }

        [HttpGet]
        [Route("Produkte abrufen")]
        öffentliche asynchrone Task<IActionResult> GetProducts()
        {
            _logger.LogInformation($"Warenkorb - Produkte abrufen");
            var Produkte = warte auf _daprClient.InvokeMethodAsync<List<string>>(HttpMethod.Get, "ProductDemo", "/api/Product/GetAll");
            Rückgabe Ok(Produkte);
        }
    }

Laden Sie das Programm auf den Linux-Server hoch und führen Sie es aus

# Starten Sie das Cart-Projekt dapr run --app-id CartDemo --app-port 5020 --dapr-http-port 7025 -- dotnet /root/www/cart/Dapr.Cart.Sample.dll --urls http://*:5020

Beim Aufrufen der Schnittstelle können Sie sehen, dass das Cart-Projekt den Schnittstellenaufruf nahezu ohne Codeeingriff implementiert.

[root@localhost ~]# curl -X 'GET' 'http://192.168.2.110:5020/api/Cart/GetProducts'
["aa","bb","cc","dd","ee","ff","gg","hh","ii","jj","kk","ll","mm","nn"]

Dapr verwendet mDns intern für die Dienstregistrierung, Erkennung und Lastverteilung. Nach der Bereitstellung mehrerer Produkte können Sie die Auswirkungen von Polling-Aufrufen sehen.

Im selbstgehosteten Modus verwendet Dapr mDNS, um danach zu suchen. Beim Ausführen im Kubernetes-Modus bestimmt der Kubernetes-DNS-Dienst die Adresse.

Bei Anruffehlern und vorübergehenden Fehlern wird der Dienstaufruf automatisch wiederholt. Dapr aktiviert Wiederholungsversuche standardmäßig. Daher ist es sehr gefährlich, wenn die Schnittstelle Idempotenz nicht unterstützt.

4.2. Veröffentlichen und Abonnieren

Der Publish-Subscribe-Modus wird hauptsächlich für Microservices verwendet, um basierend auf Nachrichten miteinander zu kommunizieren. Sie können auch sagen, das muss auch erwähnt werden, ich werde einfach ein RabbitMQ/Kafka bauen,

Es stellt sich heraus, dass wir je nach den verwendeten Komponenten unterschiedliche SDKs einführen werden und dass die Überwachungs- und Verbrauchsmodi verschiedener Nachrichtenwarteschlangen unterschiedlich sind.

Dapr stellt einen Baustein bereit, der die Implementierung der Publish/Subscribe-Funktionalität erheblich vereinfacht. Dadurch erfolgt eine Entkopplung von der zugrunde liegenden Infrastruktur und beim Schreiben der Geschäftslogik müssen Sie sich keine Gedanken über Nachrichtenwarteschlangen machen.

Fügen Sie dem Programm Publish-Subscribe-Unterstützung hinzu

 app.UseCloudEvents();
        app.UseEndpoints(Endpunkte =>
        {
            Endpunkte.MapSubscribeHandler();
        });

Abonnieren Sie Nachrichten, verwenden Sie die Themenfunktion, geben Sie Pubsub und Themennamen weiter

 [Thema("pubsub", "neuerBenutzer")]
        öffentliche ActionResult subUserInfo(UserInfo uns)
        {
            _logger.LogInformation($"Abonnementnachricht empfangen id:{us.id} name:{us.name}, age:{us.age}, sex:{us.sex}");
            return Ok("Verarbeitung abgeschlossen");
        }

Um eine Nachricht zu veröffentlichen, verwenden Sie die öffentliche dapr-Methode PublishEventAsync und übergeben Sie die Pubsub- und Themennamen sowie den Nachrichtentext.

[HttpPost]
        öffentliche asynchrone Task<IActionResult> PubUserInfo(UserInfo us)
        {
            warte auf _daprClient.PublishEventAsync("pubsub", "newUser", us);
            gibt Ok zurück();
        }

Die Komponente zum Veröffentlichen und Abonnieren von Nachrichten unterstützt RabbitMQ, Redis, Kafka usw.

4.3 Zustandsverwaltung

​Dapr verwendet standardmäßig Redis als Statusspeicher. Es unterstützt auch MongoDB, PostgreSQL, SQL Server usw.

Die von der darunterliegenden Schicht verwendete Middleware wird nicht der oberen Schicht zugänglich gemacht. Dies bedeutet, dass derselbe Codesatz verwendet werden kann, um unterschiedliche Middleware in unterschiedlichen Umgebungen zu verwenden.

[HttpPost]
       [Route("Benutzerliste Speichern")]
        öffentliche asynchrone Task<IActionResult> SaveUserList()
        {
            var temps = neue Liste<Benutzerinfo>
            {
                neue Benutzerinfo ("Xiaohong", 1, true, Guid.NewGuid().ToString()),
                neue UserInfo("Benutzerinfo",1,true,Guid.NewGuid().ToString()),
                neue UserInfo("Benutzerinfo",1,true,Guid.NewGuid().ToString())
            };
          	warte auf _daprClient.SaveStateAsync("statestore", "UserList", temps);
            gibt Ok(1) zurück;
        }
        [HttpGet]
        [Route("Benutzerliste abrufen")]
        öffentliche asynchrone Task<IActionResult> GetUserList()
        {
            var Liste = warte auf _daprClient.GetStateAsync<Liste<Benutzerinfo>>("statestore", "Benutzerliste");
            gibt Ok(Liste) zurück;
        }
      	[HttpGet]
        [Route("Benutzerliste löschen")]
        öffentliche asynchrone Task<IActionResult> DeleteUserList()
        {
            warte auf _daprClient.DeleteStateAsync("statestore", "UserList");
            gibt Ok(1) zurück;
        }

        öffentlicher Datensatz UserInfo (String-Name, Int-Alter, Bool-Geschlecht, String-ID);

4.4 Link-Tracking

Bei herkömmlichen Microservices erfordert das Link-Tracking einen starken Code-Eingriff.

Dapr fügt Sidecar eine http/grpc-Middleware hinzu. Fängt den gesamten Anwendungsverkehr ab und fügt automatisch Korrelations-IDs ein, um verteilte Transaktionen zu verfolgen.

Die verteilte Ablaufverfolgung mithilfe des Zipkin-Protokolls verfolgt automatisch den gesamten Datenverkehr ohne Code-Instrumentierung mit konfigurierbaren Ablaufverfolgungsebenen.

 5. Zusammenfassung

Dieser Artikel enthält nur ein einfaches Beispiel für Dapr und geht nicht näher auf die spezifischen Implementierungsprinzipien der einzelnen Komponenten ein.

Der größte Vorteil von Dapr im Vergleich zu herkömmlichen Microservice-Frameworks ist Sidecar. Frühere Microservice-Frameworks erforderten, dass Codeprojekte auf einige Microservice-bezogene Klassenbibliotheken verwiesen. Ob Serviceregistrierung und -erkennung, Circuit Breaking, Konfiguration usw., sie alle mussten zur Implementierung die entsprechenden Klassenbibliotheken aufrufen. Diese Klassenbibliotheken wurden im Microservice-Prozess ausgeführt, sodass diese Klassenbibliotheken in derselben (oder einer kompatiblen) Sprache wie der Geschäftscode entwickelt werden mussten, sodass sie relativ schwer waren.

Das Sidecar-Modell trennt die Funktionen von Microservices wie „Registrierungserkennung, Leistungsschalter und Konfiguration“ in einen unabhängigen Prozess, der den Prozess des Geschäftscodes begleitet. Der Geschäftscode kommuniziert über http oder grpc mit dem Sidecar-Prozess, um den Aufruf verwandter Dienste des Microservices abzuschließen.

Offensichtlich gibt es im Sidecar-Modus nur wenige Codes im Geschäftscode, die mit dem Sidecar-Prozess kommunizieren, sodass er sehr leichtgewichtig ist. Auf diese Weise können Dienste im Sidecar-Prozess unabhängig voneinander aktualisiert und Module frei kombiniert werden, ohne den Geschäftscode zu beeinträchtigen. Da der Sidecar-Prozess ein unabhängiger Prozess ist, kommunizieren der Geschäftscode und der Sidecar-Prozess gleichzeitig über sprachunabhängige Protokolle wie http und grpc, sodass der Geschäftscode in jeder beliebigen Sprache entwickelt werden kann.

Dies ist das Ende dieses Artikels über die Verwendung von Dapr zur Vereinfachung von Microservices von Grund auf. Weitere relevante Inhalte zu vereinfachten Dapr-Microservices finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder durchsuchen Sie die verwandten Artikel weiter unten. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!