Testowanie lokalnie przy użyciu emulatora usługi Azure Event Hubs

W tym artykule przedstawiono podsumowanie kroków opracowywania i testowania lokalnego przy użyciu emulatora usługi Azure Event Hubs.

Wymagania wstępne

• Docker Desktop
• Minimalne wymagania sprzętowe:
  • 2 GB pamięci RAM
  • 5 GB miejsca na dysku
• konfiguracja Podsystem Windows dla systemu Linux (tylko dla systemu Windows):
  • Instalowanie programu WSL
  • Konfigurowanie platformy Docker do korzystania z usługi WSL

Uwaga

Przed kontynuowaniem kroków opisanych w tym artykule upewnij się, że program Docker Desktop działa w tle.

Uruchamianie emulatora

Aby uruchomić emulator usługi Event Hubs, możesz użyć zautomatyzowanego skryptu lub kontenera systemu Linux:

Skrypt zautomatyzowany

Przed uruchomieniem zautomatyzowanego skryptu sklonuj repozytorium instalatora GitHub emulatora lokalnie.

Windows

Wykonaj poniższe kroki, aby uruchomić emulator usługi Event Hubs lokalnie w systemie Windows.

1. Otwórz program PowerShell i przejdź do katalogu, w którym sklonowany jest folder skryptów common przy użyciu cd:

   cd <path to your common scripts folder> # Update this path
   
   

2. Wydaj polecenie wsl, aby otworzyć program WSL w tym katalogu.

   wsl
   
   

3. Uruchom skrypt instalacyjny./LaunchEmulator.sh Uruchomienie skryptu powoduje wyświetlenie dwóch kontenerów: emulatora usługi Event Hubs i Azurite (zależności dla emulatora).

   ./Launchemulator.sh
   
   
   

Linux i macOS

Aby uruchomić emulator usługi Event Hubs lokalnie w systemie Linux lub macOS:

• Uruchom skrypt konfiguracji LaunchEmulator.sh. Uruchomienie skryptu powoduje wyświetlenie dwóch kontenerów: emulator usługi Event Hubs i Azurite (zależność emulatora).

Docker (kontener systemu Linux)

1. Aby uruchomić emulator, podaj konfigurację jednostek, których chcesz użyć. Zapisz następujący plik JSON lokalnie jako config.json:

   {
       "UserConfig": {
           "NamespaceConfig": [
           {
               "Type": "EventHub",
               "Name": "emulatorNs1",
               "Entities": [
               {
                   "Name": "eh1",
                   "PartitionCount": "2",
                   "ConsumerGroups": [
                   {
                       "Name": "cg1"
                   }
                   ]
               }
               ]
           }
           ], 
           "LoggingConfig": {
               "Type": "File"
           }
       }
   }
   
   

2. Aby uruchomić kontenery dla emulatora usługi Event Hubs, zapisz następujący plik yaml jako plik docker-compose.yaml.

name: microsoft-azure-eventhubs
services:
  emulator:
    container_name: "eventhubs-emulator"
    image: "mcr.microsoft.com/azure-messaging/eventhubs-emulator:latest"
    pull_policy: always
    volumes:
      - "${CONFIG_PATH}:/Eventhubs_Emulator/ConfigFiles/Config.json"
    ports:
      - "5672:5672"
      - "9092:9092"
      - "5300:5300"
    environment:
      BLOB_SERVER: azurite
      METADATA_SERVER: azurite
      ACCEPT_EULA: ${ACCEPT_EULA}
    depends_on:
      - azurite
    networks:
      eh-emulator:
        aliases:
          - "eventhubs-emulator"
  azurite:
    container_name: "azurite"
    image: "mcr.microsoft.com/azure-storage/azurite:latest"
    pull_policy: always
    ports:
      - "10000:10000"
      - "10001:10001"
      - "10002:10002"
    networks:
      eh-emulator:
        aliases:
          - "azurite"
networks:
  eh-emulator:

3. Utwórz plik env, aby zadeklarować zmienne środowiskowe emulatora usługi Event Hubs:

   # Centralized environment variables store for docker-compose
   
   # 1. CONFIG_PATH: Path to config.json file
   CONFIG_PATH="<Replace with path to config.json file>" 
   
   # 2. ACCEPT_EULA: Pass 'Y' to accept license terms. 
   ACCEPT_EULA="N"
   
   

   Argument ACCEPT_EULA potwierdza postanowienia licencyjne dotyczące oprogramowania firmy Microsoft. Pamiętaj, aby umieścić plik env w tym samym katalogu co plik docker-compose.yaml .

   Ważne

   Podczas określania ścieżek plików w systemie Windows użyj podwójnych ukośników odwrotnych (\\) zamiast pojedynczych ukośników odwrotnych (\), aby uniknąć pomyłek z znakami ucieczki.

4. Aby uruchomić emulator, wykonaj następujące polecenie:

    docker compose -f <PathToDockerComposeFile> up -d
   

Po pomyślnym wykonaniu tych kroków można znaleźć kontenery uruchomione na platformie Docker.

Interakcja z emulatorem

Domyślnie emulator używa config.json pliku konfiguracji. Jednostki (tematy usługi Event Hubs/Kafka) można skonfigurować, wprowadzając zmiany w pliku konfiguracji. Aby dowiedzieć się więcej, odwiedź stronę wprowadzanie zmian konfiguracji

Do nawiązania połączenia z emulatorem usługi Event Hubs można użyć następujących parametry połączenia:

• Gdy kontener emulatora i aplikacja współdziałają natywnie na komputerze lokalnym, użyj następujących parametry połączenia:

"Endpoint=sb://localhost;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=SAS_KEY_VALUE;UseDevelopmentEmulator=true;"

• Aplikacje (konteneryzowane/niekontenerowane) na różnych maszynach i tej samej sieci lokalnej mogą wchodzić w interakcję z emulatorem przy użyciu adresu IPv4 maszyny. Użyj następujących parametry połączenia:

"Endpoint=sb://192.168.y.z;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=SAS_KEY_VALUE;UseDevelopmentEmulator=true;"

• Kontenery aplikacji w tej samej sieci mostka mogą wchodzić w interakcje z emulatorem przy użyciu aliasu lub adresu IP. Po parametry połączenia przyjęto założenie, że nazwa emulatora ma wartość domyślną"eventhubs-emulator":

"Endpoint=sb://eventhubs-emulator;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=SAS_KEY_VALUE;UseDevelopmentEmulator=true;"

• Kontenery aplikacji w innej sieci mostka mogą współdziałać z emulatorem przy użyciu hosta "host.docker.internal". Użyj następujących parametry połączenia:

"Endpoint=sb://host.docker.internal;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=SAS_KEY_VALUE;UseDevelopmentEmulator=true;"

Korzystanie z platformy Kafka

Podczas interakcji z platformą Kafka upewnij się, że ustawiono konfigurację producent i odbiorca w następujący sposób:

        {
            BootstrapServers =  //Value of bootstrap servers would depend on kind of connection string being used
            SecurityProtocol = SecurityProtocol.SaslPlaintext,
            SaslMechanism = SaslMechanism.Plain,
            SaslUsername = "$ConnectionString",
            SaslPassword = //Value of connection string would depend on topology
        };

Wartość bootstrapServers i SaslPassword zależy od topologii konfiguracji. Aby uzyskać szczegółowe informacje, zobacz sekcję Interakcja z emulatorem .

Ważne

W przypadku korzystania z platformy Kafka tylko interfejsy API producentów i konsumentów są zgodne z emulatorem usługi Event Hubs.

Korzystanie z protokołu AMQP

Najnowsze wersje zestawu SDK klienta umożliwiają interakcję z emulatorem w różnych językach programowania. Aby uzyskać szczegółowe informacje, zobacz Zestawy SDK klienta.

Aby rozpocząć, zapoznaj się z przykładami emulatora usługi Event Hubs w witrynie GitHub.

Powiązana zawartość

Omówienie emulatora usługi Azure Event Hubs