Konfiguracja potoku brzegowego usługi Azure Monitor

Artykuł
04/30/2024

Potok usługi Azure Monitor to potok pozyskiwania danych zapewniający spójne i scentralizowane zbieranie danych dla usługi Azure Monitor. Potok brzegowy 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 brzegowego w środowisku.

Omówienie

Potok brzegowy usługi Azure Monitor 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 krawędzi. 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 brzegowego. 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

Link prywatny jest obsługiwany przez potok brzegowy dla połączenia z potokiem chmury.

Następujące składniki i konfiguracje są wymagane do włączenia potoku brzegowego usługi Azure Monitor. Jeśli używasz witryny Azure Portal do konfigurowania potoku brzegowego, 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 Edge 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 Edge 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 Połączenie istniejącego klastra Kubernetes do usługi 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 brzegowego. 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 brzegowego i przekazywania ich do potoku chmury 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 brzegowego.
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 brzegowy 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 brzegowego 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 brzegowy tak, 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.

Włączanie i konfigurowanie potoku

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

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: -Syslog - 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.

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 brzegowego usługi Azure Monitor 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 brzegowego 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 brzegowego. Konfiguracja potoku brzegowego 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 potoku brzegowym.

{
    "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 wystąpienia potoku brzegowego 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 kontrolera domeny, w którym potok brzegowy 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

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

Wszystkie wymagane składniki potoku usługi Azure Monitor edge można wdrożyć przy użyciu jednego 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.

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 potoku. Użyj następującego polecenia, aby pobrać ten adres:

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 usługi nginx-controller-service z typem modułu równoważenia obciążenia. Jeśli aplikacja znajduje się na zasobniku w klastrze, skopiuj wartość cluster-ip . 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 syslog.
OTLP	Potok krawędzi usługi Azure Monitor uwidacznia punkt końcowy OTLP oparty na protokole GRPC na porcie 4317. Skonfigurowanie instrumentacji w celu wysł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).

Klient

opis

Dziennik systemu

Zaktualizuj klientów dziennika systemowego, aby wysyłali dane do punktu końcowego potoku i portu przepływu danych syslog.

OTLP

Potok krawędzi usługi Azure Monitor uwidacznia punkt końcowy OTLP oparty na protokole GRPC na porcie 4317. Skonfigurowanie instrumentacji w celu wysł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.

Udostępnij za pośrednictwem