Konfiguracja potoku usługi Azure Monitor na brzegu

Potok usługi Azure Monitor to potok pozyskiwania danych zapewniający spójne i scentralizowane zbieranie danych dla usługi Azure Monitor. Potok na brzegu umożliwia zbieranie na dużą skalę i routing danych telemetrycznych przed wysłaniem ich do chmury. Dane mogą być buforowane lokalnie i synchronizowane z chmurą po przywróceniu łączności i przekierowaniu danych telemetrycznych do usługi Azure Monitor w przypadkach, gdy sieć jest segmentowana, a dane nie mogą być wysyłane bezpośrednio do chmury. W tym artykule opisano sposób włączania i konfigurowania potoku na brzegu środowiska.

Omówienie

Potok usługi Azure Monitor na brzegu to konteneryzowane rozwiązanie, które jest wdrażane w klastrze Kubernetes z obsługą usługi Arc i korzysta z modułu zbierającego OpenTelemetry jako podstawy. Na poniższym diagramie przedstawiono składniki potoku na brzegu. Co najmniej jeden przepływ danych nasłuchuje danych przychodzących od klientów, a rozszerzenie potoku przekazuje dane do chmury przy użyciu lokalnej pamięci podręcznej w razie potrzeby.

Plik konfiguracji potoku definiuje przepływy danych i właściwości pamięci podręcznej dla potoku na brzegu. Kontroler domeny definiuje schemat danych wysyłanych do potoku chmury, przekształcenia w celu filtrowania lub modyfikowania danych oraz miejsca docelowego, w którym mają być wysyłane dane. Każda definicja przepływu danych dla konfiguracji potoku określa kontroler domeny i strumień w ramach tego kontrolera domeny, który będzie przetwarzać te dane w potoku chmury.

Uwaga

Łącze prywatne jest obsługiwane przez potok na brzegu na potrzeby połączenia z potokiem chmury.

Następujące składniki i konfiguracje są wymagane do włączenia potoku usługi Azure Monitor na urządzeniach brzegowych. Jeśli używasz witryny Azure Portal do konfigurowania potoku na brzegu sieci, każdy z tych składników zostanie utworzony dla Ciebie. W przypadku innych metod należy skonfigurować poszczególne metody.

Składnik	opis
Rozszerzenie kontrolera potoku krawędzi	Rozszerzenie dodane do klastra Kubernetes z obsługą usługi Arc w celu obsługi funkcji potoku — microsoft.monitor.pipelinecontroller.
Wystąpienie kontrolera potoku usługi Edge	Wystąpienie potoku brzegowego uruchomionego w klastrze Kubernetes z obsługą usługi Arc.
Przepływ danych	Kombinacja odbiorników i eksporterów uruchamianych w wystąpieniu kontrolera potoku. Odbiorcy akceptują dane od klientów i eksporterów w celu dostarczenia tych danych do usługi Azure Monitor.
Konfiguracja potoku	Plik konfiguracji definiujący przepływy danych dla wystąpienia potoku. Każdy przepływ danych obejmuje odbiornik i eksportera. Odbiornik nasłuchuje danych przychodzących, a eksporter wysyła dane do miejsca docelowego.
Punkt końcowy zbierania danych (DCE)	Punkt końcowy, w którym dane są wysyłane do potoku usługi Azure Monitor. Konfiguracja potoku zawiera właściwość adresu URL kontrolera domeny, aby wystąpienie potoku wiedziało, gdzie wysłać dane.

Konfigurowanie	opis
Reguła zbierania danych (DCR)	Plik konfiguracji definiujący sposób odbierania danych w potoku chmury i miejsca ich wysyłania. Kontroler domeny może również zawierać przekształcenie w celu filtrowania lub modyfikowania danych przed wysłaniem ich do miejsca docelowego.
Konfiguracja potoku	Konfiguracja, która definiuje przepływy danych dla wystąpienia potoku, w tym przepływy danych i pamięć podręczną.

Obsługiwane konfiguracje

Obsługiwane dystrybucje
Potok usługi Azure Monitor na brzegu jest obsługiwany w następujących dystrybucjach platformy Kubernetes:

• Canonical
• Dostawca interfejsu API klastra dla platformy Azure
• K3
• Rancher Kubernetes Engine
• VMware Tanzu Kubernetes Grid

Obsługiwane lokalizacje
Potok usługi Azure Monitor na urządzeniach brzegowych jest obsługiwany w następujących regionach świadczenia usługi Azure:

• Wschodnie stany USA 2
• Zachodnie stany USA 2
• West Europe

Wymagania wstępne

• Klaster Kubernetes z obsługą usługi Arc we własnym środowisku z zewnętrznym adresem IP. Aby uzyskać szczegółowe informacje na temat włączania usługi Arc dla klastra, zobacz Łączenie istniejącego klastra Kubernetes z usługą Azure Arc .
• Klaster Kubernetes z obsługą usługi Arc musi mieć włączone funkcje lokalizacji niestandardowych. Zobacz Tworzenie lokalizacji niestandardowych i zarządzanie nimi na platformie Kubernetes z obsługą usługi Azure Arc.
• Obszar roboczy usługi Log Analytics w usłudze Azure Monitor umożliwiający odbieranie danych z potoku na brzegu. Aby uzyskać szczegółowe informacje na temat tworzenia obszaru roboczego, zobacz Tworzenie obszaru roboczego usługi Log Analytics w witrynie Azure Portal .
• W ramach subskrypcji platformy Azure muszą być zarejestrowani następujący dostawcy zasobów. Zobacz Dostawcy i typy zasobów platformy Azure.
  • Microsoft.Insights
  • Microsoft.Monitor

Przepływ pracy

Nie potrzebujesz szczegółowego zrozumienia różnych kroków wykonywanych przez potok usługi Azure Monitor, aby skonfigurować go przy użyciu witryny Azure Portal. Może być konieczne bardziej szczegółowe zrozumienie tego rozwiązania, jeśli używasz innej metody instalacji lub jeśli musisz wykonać bardziej zaawansowaną konfigurację, taką jak przekształcanie danych przed zapisaniem ich w miejscu docelowym.

W poniższych tabelach i diagramach opisano szczegółowe kroki i składniki procesu zbierania danych przy użyciu potoku na brzegu i przekazywania ich do potoku w chmurze dla magazynu w usłudze Azure Monitor. W tabelach znajduje się również konfiguracja wymagana dla każdego z tych składników.

Krok	Akcja	Konfiguracja pomocnicza
1.	Klient wysyła dane do odbiornika potoku brzegowego.	Klient jest skonfigurowany przy użyciu adresu IP i portu odbiornika potoku brzegowego i wysyła dane w oczekiwanym formacie dla typu odbiorcy.
2.	Odbiorca przekazuje dane eksporterowi.	Odbiornik i eksporter są konfigurowane w tym samym potoku.
3.	Eksporter próbuje wysłać dane do potoku chmury.	Eksporter w konfiguracji potoku zawiera adres URL DCE, unikatowy identyfikator dcR i strumień w kontrolerze domeny, który definiuje sposób przetwarzania danych.
3a.	Eksporter przechowuje dane w lokalnej pamięci podręcznej, jeśli nie może nawiązać połączenia z kontrolerem domeny.	Trwały wolumin pamięci podręcznej i konfiguracji lokalnej pamięci podręcznej jest włączony w konfiguracji potoku.

Krok	Akcja	Konfiguracja pomocnicza
4.	Potok chmury akceptuje dane przychodzące.	Kontroler domeny zawiera definicję schematu dla strumienia przychodzącego, która musi być zgodna ze schematem danych pochodzących z potoku na brzegu.
5.	Potok chmury stosuje transformację do danych.	Kontroler domeny zawiera przekształcenie, które filtruje lub modyfikuje dane przed wysłaniem ich do miejsca docelowego. Przekształcenie może filtrować dane, usuwać lub dodawać kolumny albo całkowicie zmieniać jego schemat. Dane wyjściowe przekształcenia muszą być zgodne ze schematem tabeli docelowej.
6.	Potok chmury wysyła dane do miejsca docelowego.	Kontroler domeny zawiera miejsce docelowe, które określa obszar roboczy usługi Log Analytics i tabelę, w której będą przechowywane dane.

Sieć segmentowana

Segmentacja sieci to model, w którym używasz zdefiniowanych przez oprogramowanie obwodów do tworzenia innego stanu zabezpieczeń dla różnych części sieci. W tym modelu może istnieć segment sieci, który nie może łączyć się z Internetem ani z innymi segmentami sieci. Potok na brzegu sieci może służyć do zbierania danych z tych segmentów sieci i wysyłania ich do potoku chmury.

Aby użyć potoku usługi Azure Monitor w konfiguracji sieci warstwowej, należy dodać następujące wpisy do listy dozwolonych klastra Kubernetes z obsługą usługi Arc. Zobacz Konfigurowanie usługi Azure IoT Layered Network Management (wersja zapoznawcza) na poziomie 4 klastra.

- destinationUrl: "*.ingest.monitor.azure.com"
  destinationType: external
- destinationUrl: "login.windows.net"
  destinationType: external

Tworzenie tabeli w obszarze roboczym usługi Log Analytics

Przed skonfigurowaniem procesu zbierania danych dla potoku na brzegu należy utworzyć tabelę w obszarze roboczym usługi Log Analytics, aby odbierać dane. Musi to być tabela niestandardowa, ponieważ wbudowane tabele nie są obecnie obsługiwane. Schemat tabeli musi być zgodny z odbierającymi danymi, ale w procesie zbierania istnieje wiele kroków, w których można modyfikować dane przychodzące, dlatego schemat tabeli nie musi być zgodny z zbierającymi danymi źródłowymi. Jedynym wymaganiem dla tabeli w obszarze roboczym usługi Log Analytics jest to, że ma kolumnę TimeGenerated .

Aby uzyskać szczegółowe informacje na temat różnych metod tworzenia tabeli, zobacz Dodawanie lub usuwanie tabel i kolumn w dziennikach usługi Azure Monitor. Na przykład użyj poniższego polecenia interfejsu wiersza polecenia, aby utworzyć tabelę z trzema kolumnami o nazwie Body, TimeGeneratedi SeverityText.

az monitor log-analytics workspace table create --workspace-name my-workspace --resource-group my-resource-group  --name my-table_CL --columns TimeGenerated=datetime Body=string SeverityText=string

Włącz pamięć podręczną

Urządzenia brzegowe w niektórych środowiskach mogą występować sporadycznie z powodu różnych czynników, takich jak przeciążenie sieci, interferencja sygnału, awaria zasilania lub mobilność. W tych środowiskach można skonfigurować potok na brzegu sieci, aby buforować dane, tworząc trwały wolumin w klastrze. Proces tego procesu będzie się różnić w zależności od konkretnego środowiska, ale konfiguracja musi spełniać następujące wymagania:

• Przestrzeń nazw metadanych musi być taka sama jak określone wystąpienie potoku usługi Azure Monitor.
• Tryb dostępu musi obsługiwać ReadWriteManyprogram .

Po utworzeniu woluminu w odpowiedniej przestrzeni nazw skonfiguruj go przy użyciu parametrów w pliku konfiguracji potoku poniżej.

Uwaga

Każda replika potoku brzegowego przechowuje dane w lokalizacji w woluminie trwałym specyficznym dla tej repliki. Zmniejszenie liczby replik, gdy klaster jest odłączony od chmury, uniemożliwi wypełnienie tych danych podczas przywracania łączności.

Dane są pobierane z pamięci podręcznej przy użyciu interfejsu FIFO (first-in-first-out). Wszystkie dane starsze niż 48 godzin zostaną odrzucone.

Włączanie i konfigurowanie potoku

Bieżące opcje włączania i konfigurowania zostały szczegółowo opisane na poniższych kartach.

Portal

Konfigurowanie potoku przy użyciu witryny Azure Portal

Jeśli używasz witryny Azure Portal do włączania i konfigurowania potoku, wszystkie wymagane składniki są tworzone na podstawie wybranych opcji. Pozwala to zaoszczędzić na złożoności tworzenia poszczególnych składników osobno, ale trzeba było użyć innych metod dla

Wykonaj jedną z następujących czynności w witrynie Azure Portal, aby uruchomić proces instalacji potoku usługi Azure Monitor:

• W menu Potoki usługi Azure Monitor (wersja zapoznawcza) kliknij pozycję Utwórz.
• Z menu klastra Kubernetes z obsługą usługi Arc wybierz pozycję Rozszerzenia, a następnie dodaj rozszerzenie potoku usługi Azure Monitor (wersja zapoznawcza).

Karta Podstawowa wyświetla następujące informacje, aby wdrożyć rozszerzenie i wystąpienie potoku w klastrze.

Ustawienia na tej karcie opisano w poniższej tabeli.

Właściwości	opis
Nazwa wystąpienia	Nazwa wystąpienia potoku usługi Azure Monitor. Musi być unikatowa dla subskrypcji.
Subskrypcja	Subskrypcja platformy Azure w celu utworzenia wystąpienia potoku.
Grupa zasobów	Grupa zasobów do utworzenia wystąpienia potoku.
Nazwa klastra	Wybierz klaster Kubernetes z obsługą usługi Arc, na którym zostanie zainstalowany potok.
Lokalizacja niestandardowa	Niestandardowa lokalizacja klastra Kubernetes z obsługą usługi Arc. Zostanie to automatycznie wypełnione nazwą lokalizacji niestandardowej, która zostanie utworzona dla klastra lub możesz wybrać inną lokalizację niestandardową w klastrze.

Karta Przepływ danych umożliwia tworzenie i edytowanie przepływów danych dla wystąpienia potoku. Każdy przepływ danych zawiera następujące szczegóły:

Ustawienia na tej karcie opisano w poniższej tabeli.

Właściwości	Opis
Nazwa/nazwisko	Nazwa przepływu danych. Musi być unikatowy dla tego potoku.
Source type	Typ zbieranych danych. Obecnie obsługiwane są następujące typy źródłowe: — Dziennik systemowy - OTLP
Port	Port, na który potok nasłuchuje danych przychodzących. Jeśli dwa przepływy danych używają tego samego portu, będą odbierać i przetwarzać dane.
Obszar roboczy usługi Log Analytics	Obszar roboczy usługi Log Analytics do wysyłania danych.
Nazwa tabeli	Nazwa tabeli w obszarze roboczym usługi Log Analytics do wysłania danych.

Interfejs wiersza polecenia

Konfigurowanie potoku przy użyciu interfejsu wiersza polecenia platformy Azure

Poniżej przedstawiono kroki wymagane do utworzenia i skonfigurowania składników wymaganych dla potoku usługi Azure Monitor na urządzeniach brzegowych przy użyciu interfejsu wiersza polecenia platformy Azure.

Rozszerzenie potoku usługi Edge

Następujące polecenie dodaje rozszerzenie potoku brzegowego do klastra Kubernetes z obsługą usługi Arc.

az k8s-extension create --name <pipeline-extension-name> --extension-type microsoft.monitor.pipelinecontroller --scope cluster --cluster-name <cluster-name> --resource-group <resource-group> --cluster-type connectedClusters --release-train Preview

## Example
az k8s-extension create --name my-pipe --extension-type microsoft.monitor.pipelinecontroller --scope cluster --cluster-name my-cluster --resource-group my-resource-group --cluster-type connectedClusters --release-train Preview

Lokalizacja niestandardowa

Poniższy szablon usługi ARM tworzy lokalizację niestandardową dla klastra Kubernetes z obsługą usługi Arc.

az customlocation create --name <custom-location-name>  --resource-group <resource-group-name> --namespace <name of namespace> --host-resource-id <connectedClusterId> --cluster-extension-ids <extensionId>

## Example
az customlocation create --name my-cluster-custom-location --resource-group my-resource-group --namespace my-cluster-custom-location --host-resource-id /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.Kubernetes/connectedClusters/my-cluster --cluster-extension-ids /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.Kubernetes/connectedClusters/my-cluster/providers/Microsoft.KubernetesConfiguration/extensions/my-cluster

DCE

Poniższy szablon usługi ARM tworzy punkt końcowy zbierania danych (DCE) wymagany dla potoku na urządzeniach brzegowych w celu nawiązania połączenia z potokiem chmury. Możesz użyć istniejącego kontrolera domeny, jeśli masz już jeden w tym samym regionie. Przed wdrożeniem szablonu zastąp właściwości w poniższej tabeli.

az monitor data-collection endpoint create -g "myResourceGroup" -l "eastus2euap" --name "myCollectionEndpoint" --public-network-access "Enabled"

## Example
 az monitor data-collection endpoint create --name strato-06-dce --resource-group strato --public-network-access "Enabled"

DcR

Kontroler domeny jest przechowywany w usłudze Azure Monitor i definiuje sposób przetwarzania danych po odebraniu ich z potoku na brzegu. Konfiguracja potoku na urządzeniach brzegowych określa immutable ID dcR i stream dcR, które będą przetwarzać dane. Element immutable ID jest generowany automatycznie podczas tworzenia kontrolera domeny.

Zastąp właściwości w poniższym szablonie i zapisz je w pliku json przed uruchomieniem polecenia interfejsu wiersza polecenia, aby utworzyć kontroler domeny. Aby uzyskać szczegółowe informacje na temat struktury kontrolera domeny, zobacz Struktura reguły zbierania danych w usłudze Azure Monitor .

Parametr	Opis
name	Nazwa kontrolera domeny. Musi być unikatowa dla subskrypcji.
location	Lokalizacja kontrolera domeny. Musi być zgodna z lokalizacją kontrolera domeny.
dataCollectionEndpointId	Identyfikator zasobu dcE.
streamDeclarations	Schemat odbieranych danych. Jeden strumień jest wymagany dla każdego przepływu danych w konfiguracji potoku. Nazwa musi być unikatowa w dcR i musi zaczynać się od custom-. Sekcje column w poniższych przykładach powinny być używane dla przepływów danych OLTP i Syslog. Jeśli schemat tabeli docelowej jest inny, można go zmodyfikować przy użyciu przekształcenia zdefiniowanego w parametrze transformKql .
destinations	Dodaj dodatkową sekcję, aby wysyłać dane do wielu obszarów roboczych.
- name	Nazwa miejsca docelowego, do którego ma odwoływać się w dataFlows sekcji. Musi być unikatowa dla kontrolera domeny.
- workspaceResourceId	Identyfikator zasobu obszaru roboczego usługi Log Analytics.
- workspaceId	Identyfikator obszaru roboczego usługi Log Analytics.
dataFlows	Pasuje do strumieni i miejsc docelowych. Jeden wpis dla każdej kombinacji strumienia/miejsca docelowego.
- streams	Co najmniej jeden strumień (zdefiniowany w pliku streamDeclarations). Możesz dołączyć wiele strumieni, jeśli są one wysyłane do tego samego miejsca docelowego.
- destinations	Co najmniej jedno miejsce docelowe (zdefiniowane w pliku destinations). Możesz dołączyć wiele miejsc docelowych, jeśli są one wysyłane do tego samego miejsca docelowego.
- transformKql	Przekształcenie w celu zastosowania do danych przed wysłaniem ich do miejsca docelowego. Użyj polecenia source , aby wysłać dane bez żadnych zmian. Dane wyjściowe przekształcenia muszą być zgodne ze schematem tabeli docelowej. Aby uzyskać szczegółowe informacje na temat przekształceń, zobacz Przekształcenia zbierania danych w usłudze Azure Monitor .
- outputStream	Określa tabelę docelową w obszarze roboczym usługi Log Analytics. Tabela musi już istnieć w obszarze roboczym. W przypadku tabel niestandardowych prefiks nazwy tabeli o nazwie Custom-. Wbudowane tabele nie są obecnie obsługiwane w przypadku potoku na brzegu.

{
    "properties": {
        "dataCollectionEndpointId": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.Insights/dataCollectionEndpoints/my-dce",
        "streamDeclarations": {
            "Custom-OTLP": {
                "columns": [
                    {
                        "name": "Body",
                        "type": "string"
                    },
                    {
                        "name": "TimeGenerated",
                        "type": "datetime"
                    },
                    {
                        "name": "SeverityText",
                        "type": "string"
                    }
                ]
            },
            "Custom-Syslog": {
                "columns": [
                    {
                        "name": "Body",
                        "type": "string"
                    },
                    {
                        "name": "TimeGenerated",
                        "type": "datetime"
                    },
                    {
                        "name": "SeverityText",
                        "type": "string"
                    }
                ]
            }
        },
        "dataSources": {},
        "destinations": {
            "logAnalytics": [
                {
                    "name": "LogAnayticsWorkspace01",
                    "workspaceResourceId": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.OperationalInsights/workspaces/my-workspace",
                    "workspaceId": "00000000-0000-0000-0000-000000000000"
                }
            ]
        },
        "dataFlows": [
            {
                "streams": [
                    "Custom-OTLP"
                ],
                "destinations": [
                    "LogAnayticsWorkspace01"
                ],
                "transformKql": "source",
                "outputStream": "Custom-OTelLogs_CL"
            },
            {
                "streams": [
                    "Custom-Syslog"
                ],
                "destinations": [
                    "LogAnayticsWorkspace01"
                ],
                "transformKql": "source",
                "outputStream": "Custom-Syslog_CL"
            }
        ]
    }
}

Zainstaluj kontroler domeny przy użyciu następującego polecenia:

az monitor data-collection rule create --name 'myDCRName' --location <location> --resource-group <resource-group>  --rule-file '<dcr-file-path.json>' 

## Example
az monitor data-collection rule create --name my-pipeline-dcr  --location westus2 --resource-group 'my-resource-group' --rule-file 'C:\MyDCR.json' 

Dostęp do kontrolera domeny

Klaster Kubernetes z obsługą usługi Arc musi mieć dostęp do kontrolera domeny w celu wysyłania danych do potoku chmury. Użyj następującego polecenia, aby pobrać identyfikator obiektu tożsamości przypisanej przez system dla klastra.

az k8s-extension show --name <extension-name> --cluster-name <cluster-name> --resource-group <resource-group> --cluster-type connectedClusters --query "identity.principalId" -o tsv 

## Example:
az k8s-extension show --name my-pipeline-extension --cluster-name my-cluster --resource-group my-resource-group --cluster-type connectedClusters --query "identity.principalId" -o tsv 

Użyj danych wyjściowych tego polecenia jako danych wejściowych do następującego polecenia, aby nadać potokowi usługi Azure Monitor uprawnienia do wysyłania danych telemetrycznych do kontrolera domeny.

az role assignment create --assignee "<extension principal ID>" --role "Monitoring Metrics Publisher" --scope "/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.Insights/dataCollectionRules/<dcr-name>" 

## Example:
az role assignment create --assignee "00000000-0000-0000-0000-000000000000" --role "Monitoring Metrics Publisher" --scope "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.Insights/dataCollectionRules/my-dcr" 

Konfiguracja potoku usługi Edge

Konfiguracja potoku brzegowego definiuje szczegóły potoku w wystąpieniu brzegowym i wdraża przepływy danych niezbędne do odbierania i wysyłania danych telemetrycznych do chmury.

Przed wdrożeniem szablonu zastąp właściwości w poniższej tabeli.

Właściwości	opis
Ogólne
name	Nazwa wystąpienia potoku. Musi być unikatowa w subskrypcji.
location	Lokalizacja wystąpienia potoku.
extendedLocation
Odbiorniki	Jeden wpis dla każdego odbiornika. Każdy wpis określa typ odbieranych danych, port, na który będzie nasłuchiwany, oraz unikatową nazwę, która będzie używana w pipelines sekcji konfiguracji.
type	Typ odebranych danych. Bieżące opcje to OTLP i Syslog.
name	Nazwa odbiorcy, do których odwołuje się service sekcja. Musi być unikatowa dla wystąpienia potoku.
endpoint	Adres i port odbiornik nasłuchuje. Użyj 0.0.0.0 dla adresów al.
Procesorów	Zarezerwowane do użytku w przyszłości.
Eksporterów	Jeden wpis dla każdego miejsca docelowego.
type	Obecnie obsługiwany typ to AzureMonitorWorkspaceLogs.
name	Musi być unikatowa dla wystąpienia potoku. Nazwa jest używana w pipelines sekcji konfiguracji.
dataCollectionEndpointUrl	Adres URL dcE, pod którym potok na brzegu będzie wysyłać dane. Możesz ją znaleźć w witrynie Azure Portal, przechodząc do kontrolera domeny i kopiując wartość pozyskiwania dzienników.
dataCollectionRule	Niezmienny identyfikator kontrolera domeny definiujący zbieranie danych w potoku chmury. W widoku JSON kontrolera domeny w witrynie Azure Portal skopiuj wartość niezmiennego identyfikatora w sekcji Ogólne .
- stream	Nazwa strumienia w kontrolerze domeny, który będzie akceptował dane.
- maxStorageUsage	Pojemność pamięci podręcznej. Po osiągnięciu 80% tej pojemności najstarsze dane są czyszczone, aby zapewnić więcej danych.
- retentionPeriod	Okres przechowywania w minutach. Dane są czyszczone po tym czasie.
- schema	Schemat danych wysyłanych do potoku chmury. Musi to być zgodne ze schematem zdefiniowanym w strumieniu w kontrolerze domeny. Schemat używany w przykładzie jest prawidłowy zarówno dla dziennika systemowego, jak i otLP.
Usługa	Jeden wpis dla każdego wystąpienia potoku. Zalecane jest tylko jedno wystąpienie dla każdego rozszerzenia potoku.
Pipelines	Jeden wpis dla każdego przepływu danych. Każdy wpis jest zgodny receiver z elementem exporter.
name	Unikatowa nazwa potoku.
receivers	Co najmniej jeden odbiornik do nasłuchiwania danych do odbierania.
processors	Zarezerwowane do użytku w przyszłości.
exporters	Co najmniej jeden eksporter wysyłający dane do potoku chmury.
persistence	Nazwa trwałego woluminu używanego dla pamięci podręcznej. Usuń ten parametr, jeśli nie chcesz włączyć pamięci podręcznej.

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "metadata": {
        "description": "This template deploys an edge pipeline for azure monitor."
    },
    "resources": [
        {
            "type": "Microsoft.monitor/pipelineGroups",
            "location": "eastus",
            "apiVersion": "2023-10-01-preview",
            "name": "my-pipeline-group-name",
            "extendedLocation": {
                "name": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.ExtendedLocation/customLocations/my-custom-location",
                "type": "CustomLocation"
            },
            "properties": {
                "receivers": [
                    {
                        "type": "OTLP",
                        "name": "receiver-OTLP",
                        "otlp": {
                            "endpoint": "0.0.0.0:4317"
                        }
                    },
                    {
                        "type": "Syslog",
                        "name": "receiver-Syslog",
                        "syslog": {
                            "endpoint": "0.0.0.0:514"
                        }
                    }
                ],
                "processors": [],
                "exporters": [
                    {
                        "type": "AzureMonitorWorkspaceLogs",
                        "name": "exporter-log-analytics-workspace",
                        "azureMonitorWorkspaceLogs": {
                            "api": {
                                "dataCollectionEndpointUrl": "https://my-dce-4agr.eastus-1.ingest.monitor.azure.com",
                                "dataCollectionRule": "dcr-00000000000000000000000000000000",
                                "stream": "Custom-OTLP",
                                "schema": {
                                    "recordMap": [
                                        {
                                            "from": "body",
                                            "to": "Body"
                                        },
                                        {
                                            "from": "severity_text",
                                            "to": "SeverityText"
                                        },
                                        {
                                            "from": "time_unix_nano",
                                            "to": "TimeGenerated"
                                        }
                                    ]
                                }
                            },
                            "cache": {
                                "maxStorageUsage": 10000,
                                "retentionPeriod": 60
                            }
                        }
                    }
                ],
                "service": {
                    "pipelines": [
                        {
                            "name": "DefaultOTLPLogs",
                            "receivers": [
                                "receiver-OTLP"
                            ],
                            "processors": [],
                            "exporters": [
                                "exporter-log-analytics-workspace"
                            ],
                            "type": "logs"
                        },
                        {
                            "name": "DefaultSyslogs",
                            "receivers": [
                                "receiver-Syslog"
                            ],
                            "processors": [],
                            "exporters": [
                                "exporter-log-analytics-workspace"
                            ],
                            "type": "logs"
                        }
                    ],
                    "persistence": {
                        "persistentVolumeName": "my-persistent-volume"
                    }
                },
                "networkingConfigurations": [
                    {
                        "externalNetworkingMode": "LoadBalancerOnly",
                        "routes": [
                            {
                                "receiver": "receiver-OTLP"
                            },
                            {
                                "receiver": "receiver-Syslog"
                            }
                        ]
                    }
                ]
            }
        }
    ]
}

Zainstaluj szablon przy użyciu następującego polecenia:

az deployment group create --resource-group <resource-group-name> --template-file <path-to-template>

## Example
az deployment group create --resource-group my-resource-group --template-file C:\MyPipelineConfig.json

ARM

Przykładowy szablon usługi ARM do konfigurowania wszystkich składników

Wszystkie wymagane składniki potoku usługi Azure Monitor można wdrożyć na urządzeniach brzegowych przy użyciu pojedynczego szablonu usługi ARM pokazanego poniżej. Edytuj plik parametrów z określonymi wartościami dla danego środowiska. Każdą sekcję szablonu opisano poniżej, w tym sekcje, które należy zmodyfikować przed jego użyciem.

Składnik	Type	Opis
Obszar roboczy usługi Log Analytics	Microsoft.OperationalInsights/workspaces	Usuń tę sekcję, jeśli używasz istniejącego obszaru roboczego usługi Log Analytics. Jedynym wymaganym parametrem jest nazwa obszaru roboczego. Niezmienny identyfikator obszaru roboczego, który jest wymagany dla innych składników, zostanie automatycznie utworzony.
Punkt końcowy zbierania danych (DCE)	Microsoft.Insights/dataCollectionEndpoints	Usuń tę sekcję, jeśli używasz istniejącego kontrolera domeny. Jedynym wymaganym parametrem jest nazwa DCE. Adres URL pozyskiwania dzienników dla kontrolera domeny, który jest wymagany dla innych składników, zostanie automatycznie utworzony.
Rozszerzenie potoku usługi Edge	Microsoft.KubernetesConfiguration/extensions	Jedynym wymaganym parametrem jest nazwa rozszerzenia potoku.
Lokalizacja niestandardowa	Microsoft.ExtendedLocation/customLocations	Niestandardowa lokalizacja klastra Kubernetes z obsługą usługi Arc w celu utworzenia niestandardowego
Wystąpienie potoku usługi Edge	Microsoft.monitor/pipelineGroups	Wystąpienie potoku usługi Edge, które obejmuje konfigurację odbiornika, eksporterów i przepływów danych. Przed wdrożeniem szablonu należy zmodyfikować właściwości wystąpienia potoku.
Reguła zbierania danych (DCR)	Microsoft.Insights/dataCollectionRules	Jedynym wymaganym parametrem jest nazwa kontrolera domeny, ale przed wdrożeniem szablonu należy zmodyfikować właściwości kontrolera domeny.

Plik szablonu

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "location": {
            "type": "string"
        },
        "clusterId": {
            "type": "string"
        },
        "clusterExtensionIds": {
            "type": "array"
        },
        "customLocationName": {
            "type": "string"
        },
        "cachePersistentVolume": {
            "type": "string"
        },
        "cacheMaxStorageUsage": {
            "type": "int"
        },
        "cacheRetentionPeriod": {
            "type": "int"
        },
        "dceName": {
            "type": "string"
        },
        "dcrName": {
            "type": "string"
        },
        "logAnalyticsWorkspaceName": {
            "type": "string"
        },
        "pipelineExtensionName": {
            "type": "string"
        },
        "pipelineGroupName": {
            "type": "string"
        },
        "tagsByResource": {
            "type": "object",
            "defaultValue": {}
        }
    },
    "resources": [
        {
            "type": "Microsoft.OperationalInsights/workspaces",            
            "name": "[parameters('logAnalyticsWorkspaceName')]",
            "location": "[parameters('location')]",
            "apiVersion": "2017-03-15-preview",
            "tags": "[ if(contains(parameters('tagsByResource'), 'Microsoft.OperationalInsights/workspaces'), parameters('tagsByResource')['Microsoft.OperationalInsights/workspaces'], json('{}')) ]",
            "properties": {
                "sku": {
                    "name": "pergb2018"
                }
            }
        },
        {
            "type": "Microsoft.Insights/dataCollectionEndpoints",            
            "name": "[parameters('dceName')]",
            "location": "[parameters('location')]",
            "apiVersion": "2021-04-01",
            "tags": "[ if(contains(parameters('tagsByResource'), 'Microsoft.Insights/dataCollectionEndpoints'), parameters('tagsByResource')['Microsoft.Insights/dataCollectionEndpoints'], json('{}')) ]",
            "properties": {
                "configurationAccess": {},
                "logsIngestion": {},
                "networkAcls": {
                    "publicNetworkAccess": "Enabled"
                }
            }
        },
        {
            "type": "Microsoft.Insights/dataCollectionRules",
            "name": "[parameters('dcrName')]",
            "location": "[parameters('location')]",
            "apiVersion": "2021-09-01-preview",
            "dependsOn": [
                "[resourceId('Microsoft.OperationalInsights/workspaces', 'DefaultWorkspace-westus2')]",
                "[resourceId('Microsoft.Insights/dataCollectionEndpoints', 'Aep-mytestpl-ZZPXiU05tJ')]"
            ],
            "tags": "[ if(contains(parameters('tagsByResource'), 'Microsoft.Insights/dataCollectionRules'), parameters('tagsByResource')['Microsoft.Insights/dataCollectionRules'], json('{}')) ]",
            "properties": {
                "dataCollectionEndpointId": "[resourceId('Microsoft.Insights/dataCollectionEndpoints', 'Aep-mytestpl-ZZPXiU05tJ')]",
                "streamDeclarations": {
                    "Custom-OTLP": {
                        "columns": [
                            {
                                "name": "Body",
                                "type": "string"
                            },
                            {
                                "name": "TimeGenerated",
                                "type": "datetime"
                            },
                            {
                                "name": "SeverityText",
                                "type": "string"
                            }
                        ]
                    },
                    "Custom-Syslog": {
                        "columns": [
                            {
                                "name": "Body",
                                "type": "string"
                            },
                            {
                                "name": "TimeGenerated",
                                "type": "datetime"
                            },
                            {
                                "name": "SeverityText",
                                "type": "string"
                            }
                        ]
                    }
                },
                "dataSources": {},
                "destinations": {
                    "logAnalytics": [
                        {
                            "name": "DefaultWorkspace-westus2",
                            "workspaceResourceId": "[resourceId('Microsoft.OperationalInsights/workspaces', 'DefaultWorkspace-westus2')]",
                            "workspaceId": "[reference(resourceId('Microsoft.OperationalInsights/workspaces', 'DefaultWorkspace-westus2'))].customerId"
                        }
                    ]
                },
                "dataFlows": [
                    {
                        "streams": [
                            "Custom-OTLP"
                        ],
                        "destinations": [
                            "localDest-DefaultWorkspace-westus2"
                        ],
                        "transformKql": "source",
                        "outputStream": "Custom-OTelLogs_CL"
                    },
                    {
                        "streams": [
                            "Custom-Syslog"
                        ],
                        "destinations": [
                            "DefaultWorkspace-westus2"
                        ],
                        "transformKql": "source",
                        "outputStream": "Custom-Syslog_CL"
                    }
                ]
            }
        },
        {
            "type": "Microsoft.KubernetesConfiguration/extensions",
            "apiVersion": "2022-11-01",
            "name": "[parameters('pipelineExtensionName')]",
            "scope": "[parameters('clusterId')]",
            "tags": "[ if(contains(parameters('tagsByResource'), 'Microsoft.KubernetesConfiguration/extensions'), parameters('tagsByResource')['Microsoft.KubernetesConfiguration/extensions'], json('{}')) ]",
            "identity": {
                "type": "SystemAssigned"
            },
            "properties": {
                "aksAssignedIdentity": {
                    "type": "SystemAssigned"
                },
                "autoUpgradeMinorVersion": false,
                "extensionType": "microsoft.monitor.pipelinecontroller",
                "releaseTrain": "preview",
                "scope": {
                    "cluster": {
                        "releaseNamespace": "my-strato-ns"
                    }
                },
                "version": "0.37.3-privatepreview"
            }
        },
        {
            "type": "Microsoft.ExtendedLocation/customLocations",
            "apiVersion": "2021-08-15",
            "name": "[parameters('customLocationName')]",
            "location": "[parameters('location')]",
            "tags": "[ if(contains(parameters('tagsByResource'), 'Microsoft.ExtendedLocation/customLocations'), parameters('tagsByResource')['Microsoft.ExtendedLocation/customLocations'], json('{}')) ]",
            "dependsOn": [
                "[parameters('pipelineExtensionName')]"
            ],
            "properties": {
                "hostResourceId": "[parameters('clusterId')]",
                "namespace": "[toLower(parameters('customLocationName'))]",
                "clusterExtensionIds": "[parameters('clusterExtensionIds')]",
                "hostType": "Kubernetes"
            }
        },
        {
            "type": "Microsoft.monitor/pipelineGroups",
            "location": "[parameters('location')]",
            "apiVersion": "2023-10-01-preview",
            "name": "[parameters('pipelineGroupName')]",
            "tags": "[ if(contains(parameters('tagsByResource'), 'Microsoft.monitor/pipelineGroups'), parameters('tagsByResource')['Microsoft.monitor/pipelineGroups'], json('{}')) ]",
            "dependsOn": [
                "[parameters('customLocationName')]",
                "[resourceId('Microsoft.Insights/dataCollectionRules','Aep-mytestpl-ZZPXiU05tJ')]"
            ],
            "extendedLocation": {
                "name": "[resourceId('Microsoft.ExtendedLocation/customLocations', parameters('customLocationName'))]",
                "type": "CustomLocation"
            },
            "properties": {
                "receivers": [
                    {
                        "type": "OTLP",
                        "name": "receiver-OTLP-4317",
                        "otlp": {
                            "endpoint": "0.0.0.0:4317"
                        }
                    },
                    {
                        "type": "Syslog",
                        "name": "receiver-Syslog-514",
                        "syslog": {
                            "endpoint": "0.0.0.0:514"
                        }
                    }
                ],
                "processors": [],
                "exporters": [
                    {
                        "type": "AzureMonitorWorkspaceLogs",
                        "name": "exporter-lu7mbr90",
                        "azureMonitorWorkspaceLogs": {
                            "api": {
                                "dataCollectionEndpointUrl": "[reference(resourceId('Microsoft.Insights/dataCollectionEndpoints','Aep-mytestpl-ZZPXiU05tJ')).logsIngestion.endpoint]",
                                "stream": "Custom-DefaultAEPOTelLogs_CL-FqXSu6GfRF",
                                "dataCollectionRule": "[reference(resourceId('Microsoft.Insights/dataCollectionRules', 'Aep-mytestpl-ZZPXiU05tJ')).immutableId]",
                                "cache": {
                                    "maxStorageUsage": "[parameters('cacheMaxStorageUsage')]",
                                    "retentionPeriod": "[parameters('cacheRetentionPeriod')]"
                                },
                                "schema": {
                                    "recordMap": [
                                        {
                                            "from": "body",
                                            "to": "Body"
                                        },
                                        {
                                            "from": "severity_text",
                                            "to": "SeverityText"
                                        },
                                        {
                                            "from": "time_unix_nano",
                                            "to": "TimeGenerated"
                                        }
                                    ]
                                }
                            }
                        }
                    }
                ],
                "service": {
                    "pipelines": [
                        {
                            "name": "DefaultOTLPLogs",
                            "receivers": [
                                "receiver-OTLP"
                            ],
                            "processors": [],
                            "exporters": [
                                "exporter-lu7mbr90"
                            ]
                        }
                    ],
                    "persistence": {
                        "persistentVolume": "[parameters('cachePersistentVolume')]"
                    }
                }
            }
        }
    ],
    "outputs": {}
}

Przykładowy plik parametrów

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "location": {
        "value": "eastus"
        },
        "clusterId": {
            "value": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.Kubernetes/connectedClusters/my-arc-cluster"
        },
        "clusterExtensionIds": {
            "value": ["/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-resource-group/providers/Microsoft.KubernetesConfiguration/extensions/my-pipeline-extension"]
        },
        "customLocationName": {
            "value": "my-custom-location"
        },
        "dceName": {
            "value": "my-dce"
        },
        "dcrName": {
            "value": "my-dcr"
        },
        "logAnalyticsWorkspaceName": {
            "value": "my-workspace"
        },
        "pipelineExtensionName": {
            "value": "my-pipeline-extension"
        },
        "pipelineGroupName": {
            "value": "my-pipeline-group"
        },
        "tagsByResource": {
            "value": {}
        }   
    }
}

Weryfikowanie konfiguracji

Weryfikowanie składników potoku uruchomionych w klastrze

W witrynie Azure Portal przejdź do menu usług Kubernetes i wybierz klaster Kubernetes z obsługą usługi Arc. Wybierz pozycję Usługi i ruch przychodzący i upewnij się, że są widoczne następujące usługi:

• <nazwa> potoku — usługa zewnętrzna
• <nazwa> potoku — usługa

Kliknij wpis nazwa <potoku-usługa> zewnętrzna i zanotuj adres IP i port w kolumnie Punkty końcowe. Jest to zewnętrzny adres IP i port, do którego klienci będą wysyłać dane. Aby pobrać ten adres z klienta, zobacz Pobieranie punktu końcowego ruchu przychodzącego.

Weryfikowanie pulsu

Każdy potok skonfigurowany w wystąpieniu potoku będzie wysyłać rekord pulsu Heartbeat do tabeli w obszarze roboczym usługi Log Analytics co minutę. Zawartość OSMajorVersion kolumny powinna być zgodna z nazwą wystąpienia potoku. Jeśli w wystąpieniu potoku znajduje się wiele obszarów roboczych, zostanie użyty pierwszy skonfigurowany obszar roboczy.

Pobierz rekordy pulsu przy użyciu zapytania dziennika, jak w poniższym przykładzie:

Konfiguracja klientów

Po zainstalowaniu rozszerzenia potoku brzegowego i wystąpienia należy skonfigurować klientów do wysyłania danych do potoku.

Pobieranie punktu końcowego ruchu przychodzącego

Każdy klient wymaga zewnętrznego adresu IP usługi potoku usługi Azure Monitor. Aby pobrać ten adres, użyj następującego polecenia:

kubectl get services -n <namespace where azure monitor pipeline was installed>

• Jeśli aplikacja tworząca dzienniki jest zewnętrzna dla klastra, skopiuj wartość external-ip nazwy> potoku usługi< lub< nazwy potoku external-service> z typem modułu równoważenia obciążenia.
• Jeśli aplikacja znajduje się na zasobniku w klastrze, skopiuj wartość cluster-ip .

Uwaga

Jeśli pole external-ip jest ustawione na oczekujące, należy skonfigurować zewnętrzny adres IP dla tego ruchu przychodzącego ręcznie zgodnie z konfiguracją klastra.

Klient	opis
Dziennik systemu	Zaktualizuj klientów dziennika systemowego, aby wysyłali dane do punktu końcowego potoku i portu przepływu danych dziennika systemowego.
OTLP	Potok krawędzi usługi Azure Monitor uwidacznia punkt końcowy OTLP oparty na protokole GRPC na porcie 4317. Skonfigurowanie instrumentacji w celu wysyłania do tego punktu końcowego OTLP będzie zależeć od samej biblioteki instrumentacji. Zobacz dokumentację dotyczącą punktu końcowego OTLP lub modułu zbierającego , aby zapoznać się z dokumentacją protokołu OpenTelemetry. Metoda zmiennej środowiskowej jest udokumentowana w temacie OTLP Exporter Configuration (Konfiguracja eksportera OTLP).

Weryfikacja danych

Ostatnim krokiem jest sprawdzenie, czy dane są odbierane w obszarze roboczym usługi Log Analytics. Tę weryfikację można wykonać, uruchamiając zapytanie w obszarze roboczym usługi Log Analytics, aby pobrać dane z tabeli.

Następne kroki

• Przeczytaj więcej na temat potoku usługi Azure Monitor.