

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# AWS Distro for OpenTelemetry をコレクターとして使用する
<a name="AMP-ingest-with-adot"></a>

このセクションでは、 AWS Distro for OpenTelemetry (ADOT) Collector を設定して Prometheus 計測アプリケーションからスクレイプし、メトリクスを Amazon Managed Service for Prometheus に送信する方法について説明します。ADOT コレクターの詳細については、「[AWS Distro for OpenTelemetry](https://aws.amazon.com/otel/)」を参照してください。

以下のトピックでは、Amazon EKS、Amazon ECS、Amazon EC2 インスタンスのいずれのメトリクスであるかに基づいて、メトリクスのコレクターとして ADOT を設定する 3 つの異なる方法について説明します。

**Topics**
+ [Amazon Elastic Kubernetes Service クラスターで AWS Distro for OpenTelemetry を使用してメトリクスの取り込みを設定する](AMP-onboard-ingest-metrics-OpenTelemetry.md)
+ [AWS Distro for Open Telemetry を使用して Amazon ECS からのメトリクス取り込みを設定する](AMP-onboard-ingest-metrics-OpenTelemetry-ECS.md)
+ [リモート書き込みを使用した Amazon EC2 インスタンスからのメトリクスの取り込みの設定](AMP-onboard-ingest-metrics-remote-write-EC2.md)

# Amazon Elastic Kubernetes Service クラスターで AWS Distro for OpenTelemetry を使用してメトリクスの取り込みを設定する
<a name="AMP-onboard-ingest-metrics-OpenTelemetry"></a>

 AWS Distro for OpenTelemetry (ADOT) コレクターを使用して、Prometheus で計測されたアプリケーションからメトリクスをスクレイプし、そのメトリクスを Amazon Managed Service for Prometheus に送信できます。

**注記**  
ADOT コレクターの詳細については、「[AWS Distro for OpenTelemetry](https://aws.amazon.com/otel/)」を参照してください。  
Prometheus でインストルメント化したアプリケーションの詳細については、「[Prometheus と互換性のあるメトリクスとはどのようなものですか。](prom-compatible-metrics.md)」を参照してください。

ADOT による Prometheus メトリクスの収集には、Prometheus Receiver、Prometheus Remote Write Exporter、Sigv4 Authentication Extension という 3 つの OpenTelemetry コンポーネントが使用されます。

既存の Prometheus の設定を使用して Prometheus Receiver を構成して、サービス検出とメトリクスのスクレイピングを実行できます。Prometheus Receiver は、メトリクスを Prometheus 公開形式でスクレイピングします。スクレイピング対象のアプリケーションやエンドポイントは、Prometheus クライアントライブラリで構成する必要があります。Prometheus Receiver は、Prometheus ドキュメントの「[Configuration](https://prometheus.io/docs/prometheus/latest/configuration/configuration/)」で説明されている Prometheus のスクレイピングと再ラベル付けの設定をすべてサポートしています。これらの設定を直接 ADOT コレクターの設定に貼り付けることができます。

Prometheus Remote Write Exporter は、`remote_write` エンドポイントを使用して、スクレイピングされたメトリクスを管理ポータルワークスペースに送信します。データをエクスポートする HTTP リクエストは、安全な認証の AWS プロトコルである AWS SigV4 と Sigv4 Authentication Extension で署名されます。詳細については、「[Signature Version 4 の署名プロセス](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)」を参照してください。

コレクターは、Amazon EKS 上の Prometheus メトリクスエンドポイントを自動的に検出し、[<kubernetes\$1sd\$1config>](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#kubernetes_sd_config) にある設定を使用します。

 以下のデモは、Amazon Elastic Kubernetes Service または自己管理型 Kubernetes を実行しているクラスターでのこの設定の例を示しています。これらのステップを実行するには、デフォルトの認証情報チェーンの潜在的なオプションのいずれかからの AWS 認証情報が必要です AWS 。詳細については、[AWS 「 SDK for Go の設定](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html)」を参照してください。このデモでは、プロセスの統合テストに使用されるサンプルアプリを使用します。このサンプルアプリは、Prometheus クライアントライブラリのように、`/metrics` エンドポイントでメトリクスを公開します。

## 前提条件
<a name="AMP-onboard-ingest-metrics-OpenTelemetry-pre"></a>

以下の取り込み設定手順を開始する前に、サービスアカウントの IAM ロールと信頼ポリシーを設定する必要があります。

**サービスアカウントの IAM ロールと信頼ポリシーを設定するには**

1. 「[Amazon EKS クラスターからメトリクスを取り込むためのサービスロールの設定](set-up-irsa.md#set-up-irsa-ingest)」の手順に従って、サービスアカウントの IAM ロールを作成します。

   ADOT コレクターは、メトリクスをスクレイピングしてエクスポートするときにこのロールを使用します。

1. 次に、信頼ポリシーを編集します。IAM コンソール ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/home)) を開きます。

1. 左側のナビゲーションペインで **[ロール]** を選択し、ステップ 1 で作成した **amp-iamproxy-ingest-role** を探します。

1. **[信頼関係]** タブを選択し、**[信頼関係の編集]** を選択します。

1. 信頼関係ポリシーの JSON で、`aws-amp` を `adot-col` に置き換えて **[信頼ポリシーの更新]** を選択します。最終的なポリシーは次のようになります。

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
           "StringEquals": {
             "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:adot-col:amp-iamproxy-ingest-service-account",
             "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
           }
         }
       }
     ]
   }
   ```

------

1. **[アクセス許可]** タブを選択し、次のアクセス許可ポリシーがロールにアタッチされていることを確認します。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "aps:RemoteWrite",
                   "aps:GetSeries",
                   "aps:GetLabels",
                   "aps:GetMetricMetadata"
               ],
               "Resource": "*"
           }
       ]
   }
   ```

------

## Prometheus メトリクスの収集の有効化
<a name="AMP-onboard-ingest-metrics-OpenTelemetry-steps"></a>

**注記**  
Amazon EKS で名前空間を作成すると、`alertmanager` とノードエクスポーターはデフォルトで無効になっています。

**Amazon EKS または Kubernetes クラスターで Prometheus の収集を有効にするには**

1. [aws-otel-community](https://github.com/aws-observability/aws-otel-community) のリポジトリから、サンプルアプリをフォークしてクローンします。

   次に、以下のコマンドを実行します。

   ```
   cd ./sample-apps/prometheus-sample-app
   docker build . -t prometheus-sample-app:latest
   ```

1. このイメージを Amazon ECR や DockerHub などのレジストリにプッシュします。

1. 次のように Kubernetes 設定をコピーして適用し、サンプルアプリをクラスターにデプロイします。`prometheus-sample-app.yaml` ファイル内の `{{PUBLIC_SAMPLE_APP_IMAGE}}` は、先ほどプッシュしたイメージに置き換えます。

   ```
   curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-sample-app.yaml -o prometheus-sample-app.yaml
   kubectl apply -f prometheus-sample-app.yaml
   ```

1. 次のコマンドを入力して、サンプルアプリが起動したことを確認します。コマンドの出力で、`NAME` 列に `prometheus-sample-app` が表示されます。

   ```
   kubectl get all -n aoc-prometheus-pipeline-demo
   ```

1. ADOT コレクターのデフォルトのインスタンスを起動します。そのためには、まず次のコマンドを入力して、ADOT コレクターの Kubernetes 設定を取得します。

   ```
   curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-daemonset.yaml -o prometheus-daemonset.yaml
   ```

   次に、テンプレートファイルを編集して、`YOUR_ENDPOINT` を Amazon Managed Service for Prometheus ワークスペースの **remote\$1write** エンドポイントに、`YOUR_REGION` を使用中のリージョンに置き換えます。ワークスペースの詳細を確認したときに Amazon Managed Service for Prometheus コンソールに表示される **remote\$1write** エンドポイントを使用してください。

   また、Kubernetes 設定のサービスアカウントセクション`YOUR_ACCOUNT_ID`の を AWS アカウント ID に変更する必要があります。

   この例では、ADOT コレクターの設定で注釈 (`scrape=true`) を使用して、スクレイピングするターゲットエンドポイントを指定しています。ADOT コレクターは、これによってサンプルアプリのエンドポイントをクラスター内の kube-system エンドポイントから区別できます。別のサンプルアプリをスクレイピングする場合は、これを再ラベル付けの設定から削除できます。

1. 次のコマンドを入力して、ADOT コレクターをデプロイします。

   ```
   kubectl apply -f prometheus-daemonset.yaml
   ```

1. 次のコマンドを入力して、ADOT コレクターが起動したことを確認します。`NAMESPACE` 列で `adot-col` を探してください。

   ```
   kubectl get pods -n adot-col
   ```

1. ログエクスポーターを使用して、パイプラインが機能することを確認します。サンプルテンプレートは既にログエクスポーターと統合されています。次のコマンドを入力します。

   ```
   kubectl get pods -A
   kubectl logs -n adot-col name_of_your_adot_collector_pod
   ```

   サンプルアプリからスクレイピングされたメトリクスの一部は、次の例のようになります。

   ```
   Resource labels:
        -> service.name: STRING(kubernetes-service-endpoints)
        -> host.name: STRING(192.168.16.238)
        -> port: STRING(8080)
        -> scheme: STRING(http)
   InstrumentationLibraryMetrics #0
   Metric #0
   Descriptor:
        -> Name: test_gauge0
        -> Description: This is my gauge
        -> Unit: 
        -> DataType: DoubleGauge
   DoubleDataPoints #0
   StartTime: 0
   Timestamp: 1606511460471000000
   Value: 0.000000
   ```

1. Amazon Managed Service for Prometheus がメトリクスを受け取ったかどうかをテストするには、`awscurl` を使用します。このツールを使用すると、 AWS Sigv4 認証を使用してコマンドラインを介して HTTP リクエストを送信できるため、Amazon Managed Service for Prometheus からクエリを実行するための正しいアクセス許可を持つ AWS 認証情報をローカルに設定する必要があります。 のインストール手順については`awscurl`、[「awscurl](https://github.com/okigan/awscurl)」を参照してください。

   次のコマンドの `AMP_REGION` と `AMP_ENDPOINT` は、Amazon Managed Service for Prometheus ワークスペースの情報に置き換えます。

   ```
   awscurl --service="aps" --region="AMP_REGION" "https://AMP_ENDPOINT/api/v1/query?query=adot_test_gauge0"
   {"status":"success","data":{"resultType":"vector","result":[{"metric":{"__name__":"adot_test_gauge0"},"value":[1606512592.493,"16.87214000011479"]}]}}
   ```

   レスポンスとしてメトリクスを受け取れば、パイプラインの設定が成功し、サンプルアプリから Amazon Managed Service for Prometheus にメトリクスが正常に伝搬されたことを意味します。

**クリーンアップ**

このデモをクリーンアップするには、次のコマンドを入力します。

```
kubectl delete namespace aoc-prometheus-pipeline-demo
kubectl delete namespace adot-col
```

## 詳細設定
<a name="AMP-otel-advanced"></a>

Prometheus Receiver は、Prometheus ドキュメントの「[Configuration](https://prometheus.io/docs/prometheus/latest/configuration/configuration/)」で説明されている Prometheus のスクレイピングと再ラベル付けの設定をすべてサポートしています。これらの設定を直接 ADOT コレクターの設定に貼り付けることができます。

Prometheus Receiver の設定には、サービス検出、スクレイピング設定、再ラベル設定が含まれます。レシーバーの設定は次のようになります。

```
receivers:
  prometheus:
    config:
      [[Your Prometheus configuration]]
```

設定ファイルの例を以下に示します。

```
receivers:
  prometheus:
    config:
      global:
        scrape_interval: 1m
        scrape_timeout: 10s
        
      scrape_configs:
      - job_name: kubernetes-service-endpoints
        sample_limit: 10000
        kubernetes_sd_configs:
        - role: endpoints
        tls_config:
          ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
          insecure_skip_verify: true
        bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
```

既存の Prometheus 設定がある場合は、値が環境変数で置き換えられないように、`$` 文字を `$$` に置き換える必要があります。\$1これは、relabel\$1configurations の replacement の値で特に重要です。例えば、次のような relabel\$1configurations があるとします。

```
relabel_configs:
- source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path]
  regex: (.+);(.+);(.+)
  replacement: ${1}://${2}${3}
  target_label: __param_target
```

これは次のように変更します。

```
relabel_configs:
- source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path]
  regex: (.+);(.+);(.+)
  replacement: $${1}://${2}${3}
  target_label: __param_target
```

**Prometheus Remote Write Exporter と Sigv4 Authentication Extension**

Prometheus Remote Write Exporter と Sigv4 Authentication Extension の設定は、Prometheus Receiver よりも簡単です。パイプラインのこの段階では、既にメトリクスが取り込まれていて、このデータを Amazon Managed Service for Prometheus にエクスポートする準備ができています。次の例は、Amazon Managed Service for Prometheus と通信するための適切な設定の最小要件を示しています。

```
extensions:
  sigv4auth:
    service: "aps"
    region: "user-region"
exporters:
  prometheusremotewrite:
    endpoint: "https://aws-managed-prometheus-endpoint/api/v1/remote_write"
    auth:
      authenticator: "sigv4auth"
```

この設定は、デフォルトの AWS 認証情報チェーンの AWS 認証情報を使用して、 AWS SigV4 によって署名された HTTPS リクエストを送信します。詳細については、「[Configuring the AWS SDK for Go](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html)」を参照してください。サービスには `aps` を指定する必要があります。

デプロイの方法にかかわらず、ADOT コレクターはデフォルトの AWS 認証情報チェーンにリストされているオプションのいずれかにアクセスできる必要があります。Sigv4 Authentication Extension は に依存し AWS SDK for Go 、それを使用して認証情報を取得して認証します。これらの認証情報に、Amazon Managed Service for Prometheus のリモート書き込みアクセス許可があることを確認する必要があります。

# AWS Distro for Open Telemetry を使用して Amazon ECS からのメトリクス取り込みを設定する
<a name="AMP-onboard-ingest-metrics-OpenTelemetry-ECS"></a>

このセクションでは、Amazon Elastic Container Service (Amazon ECS) からメトリクスを収集し、 AWS Distro for Open Telemetry (ADOT) を使用して Amazon Managed Service for Prometheus に取り込む方法について説明します。また、Amazon Managed Grafana でメトリクスを視覚化する方法についても説明します。

## 前提条件
<a name="AMP-onboard-ingest-metrics-OpenTelemetry-ECS-prereq"></a>

**重要**  
開始する前に、 AWS Fargate クラスター上のデフォルト設定の Amazon ECS 環境と、Amazon Managed Service for Prometheus ワークスペースおよび Amazon Managed Grafana ワークスペースが必要です。ユーザーがコンテナのワークロード、Amazon Managed Service for Prometheus、Amazon Managed Grafana に精通していることを前提としています。

詳細については、以下のリンクを参照してください。
+ Fargate クラスターにデフォルト設定で Amazon ECS 環境を作成する方法については、「Amazon ECS デベロッパーガイド**」の「[クラスターの作成](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html)」を参照してください。
+ Amazon Managed Service for Prometheus ワークスペースを作成する方法については、「Amazon Managed Service for Prometheus ユーザーガイド**」の「[ワークスペースの作成](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-onboard-create-workspace.html)」を参照してください。
+ Amazon Managed Grafana ワークスペースを作成する方法については、「Amazon Managed Grafana User Guide**」の「[Creating a workspace](https://docs.aws.amazon.com/grafana/latest/userguide/AMG-create-workspace.html)」を参照してください。

## ステップ 1: カスタム ADOT コレクターコンテナイメージを定義する
<a name="AMP-onboard-ingest-metrics-OpenTelemetry-ECS-create"></a>

以下の設定ファイルをテンプレートとして使用して、独自の ADOT コレクターコンテナイメージを定義します。*my-remote-URL* と *my-region* は、使用中の `endpoint` と `region` の値に置き換えます。設定を adot-config.yaml** というファイルに保存します。

**注記**  
この設定では、`sigv4auth` 拡張機能を使用して Amazon Managed Service for Prometheus への呼び出しを認証します。`sigv4auth` の構成方法の詳細については、GitHub の「[Authenticator - Sigv4](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/sigv4authextension)」を参照してください。

```
receivers:
  prometheus:
    config:
      global:
        scrape_interval: 15s
        scrape_timeout: 10s
      scrape_configs:
      - job_name: "prometheus"
        static_configs:
        - targets: [ 0.0.0.0:9090 ]
  awsecscontainermetrics:
    collection_interval: 10s
processors:
  filter:
    metrics:
      include:
        match_type: strict
        metric_names:
          - ecs.task.memory.utilized
          - ecs.task.memory.reserved
          - ecs.task.cpu.utilized
          - ecs.task.cpu.reserved
          - ecs.task.network.rate.rx
          - ecs.task.network.rate.tx
          - ecs.task.storage.read_bytes
          - ecs.task.storage.write_bytes
exporters:
  prometheusremotewrite:
    endpoint: my-remote-URL
    auth:
      authenticator: sigv4auth
  logging:
    loglevel: info
extensions:
  health_check:
  pprof:
    endpoint: :1888
  zpages:
    endpoint: :55679
  sigv4auth:
    region: my-region
    service: aps
service:
  extensions: [pprof, zpages, health_check, sigv4auth]
  pipelines:
    metrics:
      receivers: [prometheus]
      exporters: [logging, prometheusremotewrite]
    metrics/ecs:
      receivers: [awsecscontainermetrics]
      processors: [filter]
      exporters: [logging, prometheusremotewrite]
```

## ステップ 2: ADOT コレクターコンテナイメージを Amazon ECR リポジトリにプッシュする
<a name="AMP-onboard-ingest-metrics-OpenTelemetry-ECS-push"></a>

Dockerfile を使用して、コンテナイメージを作成して Amazon Elastic Container Registry (ECR) リポジトリにプッシュします。

1. Dockerfile をビルドして、コンテナイメージをコピーして OTEL Docker イメージに追加します。

   ```
   FROM public.ecr.aws/aws-observability/aws-otel-collector:latest
   COPY adot-config.yaml /etc/ecs/otel-config.yaml
   CMD ["--config=/etc/ecs/otel-config.yaml"]
   ```

1. Amazon ECR リポジトリを作成します。

   ```
   # create repo:
   COLLECTOR_REPOSITORY=$(aws ecr create-repository --repository aws-otel-collector \ 
                                  --query repository.repositoryUri --output text)
   ```

1. コンテナイメージを作成します。

   ```
   # build ADOT collector image:
   docker build -t $COLLECTOR_REPOSITORY:ecs .
   ```
**注記**  
コンテナのビルドは、そのコンテナが実行される環境と同じ環境で行うことを前提としています。そうでない場合、イメージのビルド時に `--platform` パラメータの使用が必要になることがあります。

1. Amazon ECR リポジトリにサインインします。*my-region* は、使用中の `region` の値に置き換えます。

   ```
   # sign in to repo:
   aws ecr get-login-password --region my-region | \
           docker login --username AWS --password-stdin $COLLECTOR_REPOSITORY
   ```

1. コンテナイメージをプッシュします。

   ```
   # push ADOT collector image:
   docker push $COLLECTOR_REPOSITORY:ecs
   ```

## ステップ 3: Amazon ECS タスク定義を作成して Amazon Managed Service for Prometheus をスクレイピングする
<a name="AMP-onboard-ingest-metrics-OpenTelemetry-ECS-task"></a>

Amazon Managed Service for Prometheus をスクレイピングする Amazon ECS タスク定義を作成します。タスク定義には、`adot-collector` という名前のコンテナと、`prometheus` という名前のコンテナを含める必要があります。`prometheus` はメトリクスを生成し、`adot-collector` は `prometheus` をスクレイピングします。

**注記**  
Amazon Managed Service for Prometheus はサービスとして実行され、コンテナからメトリクスを収集します。この場合のコンテナは、Prometheus をエージェントモードでローカルで実行し、ローカルのメトリクスを Amazon Managed Service for Prometheus に送信します。

**例: タスク定義**

以下の例は、タスク定義がどのようなものかを示しています。この例をテンプレートとして使用して、独自のタスク定義を作成できます。`adot-collector` の `image` の値は、リポジトリの URL とイメージタグ (`$COLLECTOR_REPOSITORY:ecs`) に置き換えます。`adot-collector` と `prometheus` の `region` の値は、使用中の `region` の値に置き換えます。

```
{
  "family": "adot-prom",
  "networkMode": "awsvpc",
  "containerDefinitions": [
    {
      "name": "adot-collector",
      "image": "account_id.dkr.ecr.region.amazonaws.com/image-tag",
      "essential": true,
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/ecs-adot-collector",
          "awslogs-region": "my-region",
          "awslogs-stream-prefix": "ecs",
          "awslogs-create-group": "True"
        }
      }
    },
    {
      "name": "prometheus",
      "image": "prom/prometheus:main",
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/ecs-prom",
          "awslogs-region": "my-region",
          "awslogs-stream-prefix": "ecs",
          "awslogs-create-group": "True"
        }
      }
    }
  ],
  "requiresCompatibilities": [
    "FARGATE"
  ],
  "cpu": "1024"
}
```

## ステップ 4: Amazon Managed Service for Prometheus にアクセスする許可をタスクに付与する
<a name="AMP-onboard-ingest-metrics-OpenTelemetry-ECS-attach"></a>

スクレイピングされたメトリクスを Amazon Managed Service for Prometheus に送信するには、Amazon ECS タスクに AWS API オペレーションを呼び出すための正しいアクセス許可が必要です。タスク用の IAM ロールを作成し、そのロールに `AmazonPrometheusRemoteWriteAccess` ポリシーをアタッチする必要があります。このロールを作成してポリシーをアタッチする方法の詳細については、「[タスク用の IAM ロールとポリシーの作成](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html#create_task_iam_policy_and_role)」を参照してください。

IAM ロールに `AmazonPrometheusRemoteWriteAccess` をアタッチし、そのロールをタスクに使用したら、スクレイピングされたメトリクスを Amazon ECS によって Amazon Managed Service for Prometheus に送信できます。

## ステップ 5: Amazon Managed Grafana でメトリクスを視覚化する
<a name="AMP-onboard-ingest-metrics-OpenTelemetry-ECS-vis"></a>

**重要**  
開始する前に、Amazon ECS タスク定義に対して Fargate タスクを実行する必要があります。そうしないと、Amazon Managed Service for Prometheus でメトリクスを使用することができません。

1. Amazon Managed Grafana ワークスペースのナビゲーションペインで、 AWS アイコンの下にある**データソース**を選択します。

1. **[データソース]** タブの **[サービス]** で、**[Amazon Managed Service for Prometheus]** を選択し、**[デフォルトのリージョン]** を選択します。

1. **[データソースの追加]** を選択します。

1. `ecs` および `prometheus` プレフィックスを使用して、メトリクスのクエリと表示を行います。

# リモート書き込みを使用した Amazon EC2 インスタンスからのメトリクスの取り込みの設定
<a name="AMP-onboard-ingest-metrics-remote-write-EC2"></a>

このセクションでは、Amazon Elastic Compute Cloud (Amazon EC2) インスタンス上で、リモート書き込みを使用する Prometheus サーバーを実行する方法について説明します。Go で記述されたデモアプリケーションからメトリクスを収集し、それらを Amazon Managed Service for Prometheus ワークスペースに送信する方法について説明します。

## 前提条件
<a name="AMP-onboard-ingest-metrics-remote-write-EC2-prereq"></a>

**重要**  
開始する前に、Prometheus v2.26 以降をインストールしておく必要があります。ユーザーが Prometheus、Amazon EC2、Amazon Managed Service for Prometheus に精通していることを前提としています。Prometheus のインストール方法については、Prometheus ウェブサイトの「[Getting started](https://prometheus.io/docs/prometheus/latest/getting_started/)」を参照してください。

Amazon EC2 または Amazon Managed Service for Prometheus に慣れていない場合は、まず以下のセクションを読むことをお勧めします。
+ [Amazon Elastic Compute Cloud とは](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html)
+ [Amazon Managed Service for Prometheus とは](https://docs.aws.amazon.com/prometheus/latest/userguide/what-is-Amazon-Managed-Service-Prometheus.html)

## Amazon EC2 用の IAM ロールの作成
<a name="AMP-onboard-ingest-metrics-remote-write-EC2-IAM"></a>

メトリクスをストリーミングするには、まず AWS 管理ポリシー **AmazonPrometheusRemoteWriteAccess** を使用して IAM ロールを作成する必要があります。その後、そのロールを持つインスタンスを起動し、Amazon Managed Service for Prometheus ワークスペースにメトリクスをストリーミングできます。

1. IAM コンソール ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)) を開きます。

1. ナビゲーションペインで **[ロール]** を選択し、**[ロールを作成]** を選択します。

1. 信頼されたエンティティの種類として **[AWS のサービス]** を選択します。ユースケースとして **[EC2]** を選択します。**[次へ: アクセス許可]** を選択します。

1. 検索バーに「**AmazonPrometheusRemoteWriteAccess**」と入力します。**[ポリシー名]** で **[AmazonPrometheusRemoteWriteAccess]** を選択し、**[ポリシーをアタッチ]** を選択します。**[次へ: タグ]** を選択します。

1. (オプション) IAM ロールに IAM タグを作成します。**[次へ: 確認]** を選択します。

1. ロールの名前を入力します。**[ポリシーを作成]** を選択します。

## Amazon EC2 インスタンスの起動
<a name="AMP-onboard-ingest-metrics-remote-write-EC2-instance"></a>

Amazon EC2 インスタンスを起動するには、「Amazon Elastic Compute Cloud Linux インスタンス用ユーザーガイド**」の「[インスタンスの起動](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#launch-instance-with-role)」の手順に従います。

## デモアプリケーションの実行
<a name="AMP-onboard-ingest-metrics-remote-write-EC2-demo"></a>

IAM ロールを作成し、そのロールを使用して EC2 インスタンスを起動したら、デモアプリケーションを実行して動作を確認できます。

**デモアプリケーションとテストメトリクスを実行するには**

1. 以下のテンプレートを使用して、`main.go` という名前の Go ファイルを作成します。

   ```
   package main
   
   import (
       "github.com/prometheus/client_golang/prometheus/promhttp"
       "net/http"
   )
   
   func main() {
       http.Handle("/metrics", promhttp.Handler())
   
       http.ListenAndServe(":8000", nil)
   }
   ```

1. 次のコマンドを実行して、適切な依存関係をインストールします。

   ```
   sudo yum update -y
   sudo yum install -y golang
   go get github.com/prometheus/client_golang/prometheus/promhttp
   ```

1. デモアプリケーションを実行します。

   ```
   go run main.go
   ```

   デモアプリケーションはポート 8000 で実行され、公開されているすべての Prometheus メトリクスを表示します。これらのメトリクスの例を以下に示します。

   ```
   curl -s http://localhost:8000/metrics 
   ...
   process_max_fds 4096# HELP process_open_fds Number of open file descriptors.# TYPE process_open_fds gauge
   process_open_fds 10# HELP process_resident_memory_bytes Resident memory size in bytes.# TYPE process_resident_memory_bytes gauge
   process_resident_memory_bytes 1.0657792e+07# HELP process_start_time_seconds Start time of the process since unix epoch in seconds.# TYPE process_start_time_seconds gauge
   process_start_time_seconds 1.61131955899e+09# HELP process_virtual_memory_bytes Virtual memory size in bytes.# TYPE process_virtual_memory_bytes gauge
   process_virtual_memory_bytes 7.77281536e+08# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes.# TYPE process_virtual_memory_max_bytes gauge
   process_virtual_memory_max_bytes -1# HELP promhttp_metric_handler_requests_in_flight Current number of scrapes being served.# TYPE promhttp_metric_handler_requests_in_flight gauge
   promhttp_metric_handler_requests_in_flight 1# HELP promhttp_metric_handler_requests_total Total number of scrapes by HTTP status code.# TYPE promhttp_metric_handler_requests_total counter
   promhttp_metric_handler_requests_total{code="200"} 1
   promhttp_metric_handler_requests_total{code="500"} 0
   promhttp_metric_handler_requests_total{code="503"} 0
   ```

## Amazon Managed Service for Prometheus ワークスペースの作成
<a name="AMP-onboard-ingest-metrics-remote-write-EC2-workspace"></a>

Amazon Managed Service for Prometheus ワークスペースを作成するには、「[Create a workspace](AMP-create-workspace.md)」の手順に従います。

## Prometheus サーバーの実行
<a name="AMP-onboard-ingest-metrics-remote-write-EC2-server"></a>

1. 以下の YAML ファイルの例をテンプレートとして使用して、`prometheus.yaml` という名前の新しいファイルを作成します。`url` については、*my-region* を使用中のリージョンの値に、*my-workspace-id* を Amazon Managed Service for Prometheus で生成されたワークスペース ID に置き換えます。`region` については、*my-region* を使用中のリージョンの値に置き換えます。

   **例: YAML ファイル**

   ```
   global:
     scrape_interval: 15s
     external_labels:
       monitor: 'prometheus'
   
   scrape_configs:
     - job_name: 'prometheus'
       static_configs:
         - targets: ['localhost:8000']
   
   remote_write:
     -
       url: https://aps-workspaces.my-region.amazonaws.com/workspaces/my-workspace-id/api/v1/remote_write
       queue_config:
           max_samples_per_send: 1000
           max_shards: 200
           capacity: 2500
       sigv4:
            region: my-region
   ```

1. Prometheus サーバーを実行して、デモアプリケーションのメトリクスを Amazon Managed Service for Prometheus ワークスペースに送信します。

   ```
   prometheus --config.file=prometheus.yaml
   ```

これで、Prometheus サーバーによってデモアプリケーションのメトリクスが Amazon Managed Service for Prometheus ワークスペースに送信されます。