# Container Insights の Prometheus メトリクスのモニターリング
CloudWatch Container Insights で Prometheus をモニターリングすると、コンテナ化されたシステムとワークロードからの Prometheus メトリクスの検出が自動化されます。Prometheus はオープンソースのシステムモニターリングおよび警告ツールキットです。詳細については、Prometheus のドキュメントの「[What is Prometheus?](https://prometheus.io/docs/introduction/overview/)」を参照してください。
Prometheus メトリクスの検出は、[Amazon Elastic Container Service](https://aws.amazon.com/ecs/)、[Amazon Elastic Kubernetes Service](https://aws.amazon.com/eks/)、および Amazon EC2 インスタンスで実行されている [Kubernetes](https://aws.amazon.com/kubernetes/) クラスターでサポートされています。Prometheus カウンタ、ゲージ、およびサマリーメトリクスタイプが収集されます。
Amazon ECS クラスターと Amazon EKS クラスターでは、EC2 と Fargate の両方の起動タイプがサポートされています。Container Insights は、複数のワークロードからメトリクスを自動的に収集し、任意のワークロードからメトリクスを収集するように設定できます。
Prometheus は、CloudWatch でカスタムメトリクスを取り込むオープンソースかつオープンスタンダードな方法として採用できます。Prometheus をサポートする CloudWatch エージェントは、Prometheus メトリクスを検出して収集し、アプリケーションのパフォーマンスの低下や障害をより迅速にモニターリング、トラブルシューティング、警告します。これにより、オブザーバビリティを強化するために必要なモニターリングツールの数も削減されます。
Container Insights の Prometheus サポートでは、収集、保存、分析などのメトリクスとログの使用量に応じて課金されます。詳細については、[Amazon CloudWatch 料金表](https://aws.amazon.com/cloudwatch/pricing/)をご覧ください。
**一部のワークロード用に構築済みのダッシュボード**
Container Insights Prometheus ソリューションには、このセクションに記載されている一般的なワークロード用の事前構築済みのダッシュボードが含まれています。これらのワークロードの設定例については、「[(オプション) Prometheus メトリクスのテストのためにコンテナ化された Amazon ECS のサンプルワークロードを設定する](ContainerInsights-Prometheus-Sample-Workloads-ECS.md)」および「[(オプション) Prometheus メトリクスのテストのためにコンテナ化された Amazon EKS サンプルワークロードを設定する](ContainerInsights-Prometheus-Sample-Workloads.md)」を参照してください。
エージェント設定ファイルを編集して、他のコンテナ化されたサービスおよびアプリケーションから Prometheus メトリクスを収集するように Container Insights を設定することもできます。
Amazon EC2 インスタンスで実行されている Amazon EKS クラスターおよび Kubernetes クラスター用の事前構築済みのダッシュボードを使用したワークロードには、以下があります。
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
Amazon ECS クラスター用の事前構築済みダッシュボードを使用したワークロードには、以下があります。
+ AWS App Mesh
+ Java/JMX
+ NGINX
+ NGINX Plus
# Amazon ECS クラスターで Prometheus メトリクスコレクションをセットアップおよび設定する
Amazon ECS クラスターから Prometheus メトリクスを収集するには、CloudWatch エージェントをコレクターとして使用するか、AWS Distro for OpenTelemetry コレクターを使用できます。AWS Distro for OpenTelemetry コレクターの使用については、[https://aws-otel.github.io/docs/getting-started/container-insights/ecs-prometheus](https://aws-otel.github.io/docs/getting-started/container-insights/ecs-prometheus) を参照してください。
以下のセクションでは、CloudWatch エージェントをコレクターとして使用して Prometheus メトリクスを取得する方法について説明します。Amazon ECS を実行しているクラスターに Prometheus モニターリングを使用して CloudWatch エージェントをインストールし、オプションで追加のターゲットをスクレイプするようにエージェントを設定することができます。また、これらのセクションでは、Prometheus モニターリングでのテストに使用するサンプルワークロードを設定するためのオプションのチュートリアルも提供します。
Amazon ECS の Container Insights は、Prometheus メトリクスの次の起動タイプとネットワークモードの組み合わせをサポートしています。
| Amazon ECS 起動タイプ | サポートされているネットワークモード |
| --- | --- |
| EC2 (Linux) | ブリッジ、ホストおよび awsvpc |
| Fargate | awsvpc |
**VPC セキュリティグループの要件**
Prometheus ワークロードのセキュリティグループの受信ルールでは、Prometheus のメトリクスをプライベート IP でスクレイピングするために、CloudWatch エージェントへの Prometheus ポートを開く必要があります。
CloudWatch エージェントのセキュリティグループの出力ルールでは、CloudWatch エージェントがプライベート IP によって Prometheus ワークロードのポートに接続できるようにする必要があります。
**Topics**
+ [Amazon ECS クラスターに Prometheus メトリクスコレクションを持つ CloudWatch エージェントをインストールする](ContainerInsights-Prometheus-install-ECS.md)
+ [追加の Prometheus ソースのスクレイピングと、それらのメトリクスのインポート](ContainerInsights-Prometheus-Setup-configure-ECS.md)
+ [(オプション) Prometheus メトリクスのテストのためにコンテナ化された Amazon ECS のサンプルワークロードを設定する](ContainerInsights-Prometheus-Sample-Workloads-ECS.md)
# Amazon ECS クラスターに Prometheus メトリクスコレクションを持つ CloudWatch エージェントをインストールする
このセクションでは、Amazon ECS を実行しているクラスターで Prometheus モニターリングを使用して CloudWatch エージェントをセットアップする方法について説明します。これを行うと、エージェントは、そのクラスターで実行されている次のワークロードのメトリクスを自動的にスクレイプし、インポートします。
+ AWS App Mesh
+ Java/JMX
また、追加の Prometheus ワークロードとソースからメトリクスをスクレイプしてインポートするようにエージェントを設定することもできます。
## IAM ロールの設定
CloudWatch エージェントタスク定義には、2 つの IAM ロールが必要です。Container Insights がこれらのロールを作成するように **CreateIAMRoles=True** スタックで CloudFormation を指定すると、ロールは正しいアクセス許可によって作成されます。お客様自身でロールを作成する場合、または既存のロールを使用する場合は、次のロールとアクセス許可が必要です。
+ **CloudWatch エージェントの ECS タスクロール** – CloudWatch エージェントコンテナはこのロールを使用します。これには、**CloudWatchAgentServerPolicy** ポリシーと、次の読み取り専用のアクセス許可を含むカスタマー管理ポリシーが含まれている必要があります。
+ `ec2:DescribeInstances`
+ `ecs:ListTasks`
+ `ecs:ListServices`
+ `ecs:DescribeContainerInstances`
+ `ecs:DescribeServices`
+ `ecs:DescribeTasks`
+ `ecs:DescribeTaskDefinition`
+ **CloudWatch エージェント ECS タスク実行ロール** – これは、コンテナを起動して実行するために Amazon ECS が必要とするロールです。タスク実行ロールに [**AmazonSSMReadOnlyAccess**]、[**AmazonECSTaskExecutionRolePolicy**]、および [**CloudWatchAgentServerPolicy**] ポリシーがアタッチされていることを確認します。Amazon ECS で使用するためにより機密性の高いデータを保存する場合は、「[機密データの指定](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html)」を参照してください。
## を使用して、Prometheus モニターリングを使用する CloudWatch エージェントをインストールするCloudFormation
AWS CloudFormation を使用して、Amazon ECS クラスターの Prometheus モニターリングで CloudWatch エージェントをインストールします。次のリストは、CloudFormation テンプレートで使用するパラメータを示しています。
+ **EcsClusterName** – ターゲット Amazon ECS クラスターを指定します。
+ **CreateIamRoles** – Amazon ECS タスク実行ロールと Amazon ECS タスクロールの新しいロールを作成するときに **True** を指定します 。既存のロールを再利用する場合に **False** を指定します。
+ **TaskRoleName** – [**CreateIAMRoles**] に **True** を指定した場合、新しい Amazon ECS タスクロールに使用する名前を指定します。[**CreateIAMRoles**] に **False** を指定した場合、Amazon ECS タスクロールとして使用する既存のロールを指定します。
+ **ExecutionRoleName** – [**CreateIAMRoles**] に **True** を指定した場合、新しい Amazon ECS タスク実行ロールに使用する名前を指定します。[**CreateIAMRoles**] に **False** を指定した場合、Amazon ECS タスク実行ロールとして使用する既存のロールを指定します。
+ **ECSNetworkMode** – EC2 起動タイプを使用している場合、ここでネットワークモードを指定します。これは **bridge** または **host** である必要があります。
+ **ECSLaunchType** – **fargate** または **EC2** を指定します。
+ **SecurityGroupID** – [**ECSNetworkMode**] が **awsvpc** である場合、ここでセキュリティグループ ID を指定します。
+ **SubnetID** – **ECSNetworkMode** が **awsvpc** の場合、ここでサブネット ID を指定します。
### コマンドサンプル
このセクションでは、さまざまなシナリオで Prometheus モニターリングを使用して Container Insights をインストールするためのサンプル CloudFormation コマンドについて説明します。
**ブリッジネットワークモードで Amazon ECS クラスターの CloudFormation スタックを作成する**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_NETWORK_MODE=bridge
export CREATE_IAM_ROLES=True
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**ホストネットワークモードで Amazon ECS クラスターの CloudFormation スタックを作成する**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_NETWORK_MODE=host
export CREATE_IAM_ROLES=True
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**awsvpc ネットワークモードで Amazon ECS クラスターの CloudFormation スタックを作成する**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_LAUNCH_TYPE=EC2
export CREATE_IAM_ROLES=True
export ECS_CLUSTER_SECURITY_GROUP=your_security_group_eg_sg-xxxxxxxxxx
export ECS_CLUSTER_SUBNET=your_subnet_eg_subnet-xxxxxxxxxx
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-${ECS_LAUNCH_TYPE}-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSLaunchType,ParameterValue=${ECS_LAUNCH_TYPE} \
ParameterKey=SecurityGroupID,ParameterValue=${ECS_CLUSTER_SECURITY_GROUP} \
ParameterKey=SubnetID,ParameterValue=${ECS_CLUSTER_SUBNET} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
** awsvpc ネットワークモードでの Fargate クラスターの CloudFormation スタックの作成**
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export ECS_CLUSTER_NAME=your_ec2_ecs_cluster_name
export ECS_LAUNCH_TYPE=FARGATE
export CREATE_IAM_ROLES=True
export ECS_CLUSTER_SECURITY_GROUP=your_security_group_eg_sg-xxxxxxxxxx
export ECS_CLUSTER_SUBNET=your_subnet_eg_subnet-xxxxxxxxxx
export ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
export ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-${ECS_LAUNCH_TYPE}-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=${CREATE_IAM_ROLES} \
ParameterKey=ECSLaunchType,ParameterValue=${ECS_LAUNCH_TYPE} \
ParameterKey=SecurityGroupID,ParameterValue=${ECS_CLUSTER_SECURITY_GROUP} \
ParameterKey=SubnetID,ParameterValue=${ECS_CLUSTER_SUBNET} \
ParameterKey=TaskRoleName,ParameterValue=${ECS_TASK_ROLE_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=${ECS_EXECUTION_ROLE_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
### AWS スタックによって作成された CloudFormation リソース
次の表は、AWS を使用して Amazon ECS クラスターで Prometheus モニターリングを使用した Container Insights をセットアップするときに作成される CloudFormation リソースの一覧です。
| リソースタイプ | リソース名 | コメント |
| --- | --- | --- |
| AWS::SSM::Parameter | AmazonCloudWatch-CWAgentConfig-\$1*ECS\$1CLUSTER\$1NAME*-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | これは、デフォルト App Mesh および Java/JMX 埋め込みメトリクス形式定義を持つ CloudWatch エージェントです。 |
| AWS::SSM::Parameter | AmazonCloudWatch-PrometheusConfigName-\$1*ECS\$1CLUSTER\$1NAME*-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | これは Prometheus のスクレイピング設定です。 |
| AWS::IAM::Role | **\$1ECS\$1TASK\$1ROLE\$1NAME**。 | Amazon ECS タスクロール。これは、**True** に `CREATE_IAM_ROLES` を指定した場合にのみ作成されます 。 |
| AWS::IAM::Role | **\$1\$1ECS\$1EXECUTION\$1ROLE\$1NAME\$1** | Amazon ECS タスク実行ロール。これは、**True** に `CREATE_IAM_ROLES` を指定した場合にのみ作成されます 。 |
| AWS::ECS::TaskDefinition | cwagent-prometheus-\$1*ECS\$1CLUSTER\$1NAME*-\$1*ECS\$1LOUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | |
| AWS::ECS::Service | cwagent-prometheus-replica-service-\$1*ECS\$1LAUNCH\$1TYPE*-\$1*ECS\$1NETWORK\$1MODE* | |
### Prometheus モニターリングを使用した CloudWatch エージェントの CloudFormation スタックの削除
Amazon ECS クラスターから CloudWatch エージェントを削除するには、次のコマンドを入力します。
```
export AWS_PROFILE=your_aws_config_profile_eg_default
export AWS_DEFAULT_REGION=your_aws_region_eg_ap-southeast-1
export CLOUDFORMATION_STACK_NAME=your_cloudformation_stack_name
aws cloudformation delete-stack \
--stack-name ${CLOUDFORMATION_STACK_NAME} \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
# 追加の Prometheus ソースのスクレイピングと、それらのメトリクスのインポート
Prometheus モニターリングを使用した CloudWatch エージェントは、Prometheus メトリクスをスクレイプするために 2 つの設定が必要です。1 つは標準の Prometheus 設定用で、Prometheus ドキュメントの「[](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config)」に記載されています。もう 1 つは CloudWatch エージェント設定用です。
Amazon ECS クラスターでは、設定は Amazon ECS タスク定義のシークレットによって AWS Systems Manager の Parameter Store と統合されます。
+ このシークレット `PROMETHEUS_CONFIG_CONTENT` は、Prometheus スクレイプ設定用です。
+ このシークレット `CW_CONFIG_CONTENT` は、 CloudWatch エージェント設定用です。
追加の Prometheus メトリクスソースをスクレイプし、それらのメトリクスを CloudWatch にインポートするには、Prometheus スクレイプ設定と CloudWatch エージェント設定の両方を変更し、更新された設定でエージェントを再デプロイします。
**VPC セキュリティグループの要件**
Prometheus ワークロードのセキュリティグループの受信ルールでは、Prometheus のメトリクスをプライベート IP でスクレイピングするために、CloudWatch エージェントへの Prometheus ポートを開く必要があります。
CloudWatch エージェントのセキュリティグループの出力ルールでは、CloudWatch エージェントがプライベート IP によって Prometheus ワークロードのポートに接続できるようにする必要があります。
## Prometheus スクレイプ設定
この CloudWatch エージェントは、Prometheus のドキュメントの「[](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config)」に記載されているように、標準の Prometheus スクレイプ設定をサポートしています。このセクションを編集して、このファイルに既に含まれている設定を更新したり、Prometheus スクレイピングターゲットを追加したりできます。デフォルトでは、サンプル設定ファイルに次のグローバル設定行が含まれています。
```
global:
scrape_interval: 1m
scrape_timeout: 10s
```
+ **scrape\$1interval** – ターゲットをスクレイプする頻度を定義します。
+ **scrape\$1timeout** – スクレイプリクエストがタイムアウトするまでの待機時間を定義します。
また、ジョブレベルでこれらの設定に対して異なる値を定義し、グローバル設定をオーバーライドすることもできます。
### Prometheus スクレイピングジョブ
CloudWatch エージェント YAML ファイルには、既にいくつかのデフォルトのスクレイピングジョブが設定されています。例えば、`cwagent-ecs-prometheus-metric-for-bridge-host.yaml` などのAmazon ECS の YAML ファイルでは、デフォルトのスクレイピングジョブが `ecs_service_discovery` セクションで設定されています。
```
"ecs_service_discovery": {
"sd_frequency": "1m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
},
"task_definition_list": [
{
"sd_job_name": "ecs-appmesh-colors",
"sd_metrics_ports": "9901",
"sd_task_definition_arn_pattern": ".*:task-definition\/.*-ColorTeller-(white):[0-9]+",
"sd_metrics_path": "/stats/prometheus"
},
{
"sd_job_name": "ecs-appmesh-gateway",
"sd_metrics_ports": "9901",
"sd_task_definition_arn_pattern": ".*:task-definition/.*-ColorGateway:[0-9]+",
"sd_metrics_path": "/stats/prometheus"
}
]
}
```
これらのデフォルトターゲットはそれぞれスクレイピングされ、メトリクスは埋め込みメトリクス形式を使用してログイベントで CloudWatch に送信されます。詳細については、「[ログ内へのメトリクスの埋め込み](CloudWatch_Embedded_Metric_Format.md)」を参照してください。
Amazon ECS クラスターからのログイベントは、[**/aws/ecs/containerinsights/*cluster\$1name*/prometheus**] ロググループに保存されます。
各スクレイピングジョブは、このロググループ内の異なるログストリームに含まれています。
新しいスクレイピングターゲットを追加するには、YAML ファイルの `task_definition_list` セクションの `ecs_service_discovery` セクションに新しいエントリを追加し、エージェントを再起動します。このプロセスの例については、「[新しい Prometheus スクレイピングターゲットを追加するためのチュートリアル: Prometheus API サーバーメトリクス](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters)」を参照してください。
## Prometheus の CloudWatch エージェント設定
CloudWatch エージェント設定ファイルには、Prometheus スクレイピング設定の `prometheus` の `metrics_collected` セクションがあります。これには、次の設定オプションが含まれます。
+ **cluster\$1name** – ログイベントのラベルとして追加されるクラスター名を指定します。このフィールドはオプションです。これを省略すると、エージェントは Amazon ECS クラスター名を検出できます。
+ **log\$1group\$1name** – スクレイプされた Prometheus メトリクスのロググループ名を指定します。このフィールドはオプションです。これを省略すると、CloudWatch では Amazon ECS クラスターからのログに**/aws/ecs/containerinsights/*cluster\$1name*/prometheus**が使用されます。
+ **prometheus\$1config\$1path** – Prometheus スクレイプ設定ファイルパスを指定します。このフィールドの値が `env:` で始まる場合、Prometheus スクレイプ設定ファイルの内容は、コンテナの環境変数から取得されます。このフィールドは変更しないでください。
+ **ecs\$1service\$1discovery** – Amazon ECS Prometheus ターゲット自動検出関数の設定を指定するセクションです。Prometheus ターゲットを検出するには、コンテナの docker ラベルに基づく検出と、Amazon ECS タスク定義の ARN 正規表現に基づく検出の 2 つのモードがサポートされています。2 つのモードを一緒に使用すると、CloudWatch エージェントは *\$1private\$1ip\$1:\$1port\$1/\$1metrics\$1path\$1* に基づいて検出されたターゲットの重複排除を行います。
`ecs_service_discovery` セクションには、次のフィールドを含めることができます。
+ `sd_frequency` は、Prometheus エクスポーターを検出する頻度です。数値と単位サフィックスを指定します。例えば、`1m` の場合は 1 分に 1 回、`30s` の場合は 30 秒に 1 回です。有効な単位サフィックスは、`ns`、`us`、`ms`、`s`、`m`、`h` です。
このフィールドはオプションです。デフォルト値は 60 秒 (1 分) です。
+ `sd_target_cluster` は、自動検出のターゲット Amazon ECS クラスター名です。このフィールドはオプションです。デフォルトは、CloudWatch エージェントがインストールされている Amazon ECS クラスターの名前です。
+ `sd_cluster_region` は、ターゲット Amazon ECS クラスターのリージョンです。このフィールドはオプションです。デフォルトは、CloudWatch エージェントがインストールされている Amazon ECS クラスターのリージョンです。
+ `sd_result_file` は、Prometheus ターゲット結果の YAML ファイルのパスです。Prometheus スクレイプ設定は、このファイルを参照します。
+ `docker_label` は、docker のラベルベースのサービス検出の設定を指定するために使用できるオプションのセクションです。このセクションを省略すると、docker のラベルベースの検出は使用されません。このセクションには、次のフィールドを含めることができます。
+ `sd_port_label` は、Prometheus メトリクスのコンテナポートを指定するコンテナの docker ラベル名です。デフォルト値は `ECS_PROMETHEUS_EXPORTER_PORT` です。コンテナにこの docker ラベルがない場合、CloudWatch エージェントはそれをスキップします。
+ `sd_metrics_path_label` は、Prometheus メトリクスパスを指定するコンテナの docker ラベル名です。デフォルト値は `ECS_PROMETHEUS_METRICS_PATH` です。コンテナにこの docker ラベルがない場合は、エージェントはデフォルトパス `/metrics` を想定します。
+ `sd_job_name_label` は、Prometheus スクレイプジョブ名を指定するコンテナの docker ラベル名です。デフォルト値は `job` です。コンテナにこの docker ラベルがない場合、CloudWatch エージェントは Prometheus スクレイプ設定でジョブ名を使用します。
+ `task_definition_list` は、タスク定義ベースのサービス検出の設定を指定するために使用できるオプションのセクションです。このセクションを省略すると、タスク定義ベースの検出は使用されません。このセクションには、次のフィールドを含めることができます。
+ `sd_task_definition_arn_pattern` は、検出する Amazon ECS タスク定義を指定するために使用するパターンです。これは正規表現です。
+ `sd_metrics_ports` に、Prometheus メトリクスの containerPort を示します。containerPort はセミコロンで区切ります。
+ `sd_container_name_pattern` は、Amazon ECS タスクコンテナ名を指定します。これは正規表現です。
+ `sd_metrics_path` は、Prometheus のメトリクスパスを指定します。これを省略すると、エージェントはデフォルトのパス `/metrics` を引き受けます。
+ `sd_job_name` Prometheus スクレイプジョブ名を指定します。このフィールドを省略すると、CloudWatch エージェントは Prometheus スクレイプ設定のジョブ名を使用します。
+ `service_name_list_for_tasks` は、サービス名ベースの検出の設定を指定するために使用できるオプションのセクションです。このセクションを省略すると、サービス名ベースの検出は使用されません。このセクションには、次のフィールドを含めることができます。
+ `sd_service_name_pattern` は、タスクを検出する Amazon ECS サービスを指定するために使用するパターンです。これは正規表現です。
+ `sd_metrics_ports` は、Prometheus メトリクスの `containerPort` をリストします。複数の `containerPorts` をセミコロンで区切ります。
+ `sd_container_name_pattern` は、Amazon ECS タスクコンテナ名を指定します。これは正規表現です。
+ `sd_metrics_path` は、Prometheus のメトリクスパスを指定します。これを省略すると、エージェントはデフォルトのパス `/metrics` を引き受けます。
+ `sd_job_name` Prometheus スクレイプジョブ名を指定します。このフィールドを省略すると、CloudWatch エージェントは Prometheus スクレイプ設定のジョブ名を使用します。
+ **metric\$1declaration** – 生成されるメトリクス形式が埋め込まれたログの配列を指定するセクションです。CloudWatch エージェントがインポートする各 Prometheus ソースには、デフォルトで `metric_declaration` セクションがあります。これらの各セクションには、次のフィールドが含まれています。
+ `label_matcher` は、 `source_labels` に表示されているラベルの値をチェックする正規表現です。一致するメトリクスは、CloudWatch に送信される埋め込みメトリクス形式に含めることができます。
`source_labels` で複数のラベルを指定する場合は、`^` の正規表現に `$` や `label_matcher` 文字を使用しないことをお勧めします。
+ `source_labels` は、`label_matcher` 行によってチェックされるラベルの値を指定します。
+ `label_separator` は、複数の ` label_matcher` が指定されている場合に、`source_labels` 行で使用するセパレータを指定します。デフォルト: `;`。このデフォルトは、次の例の `label_matcher` 行で使用されています。
+ `metric_selectors` は、収集され、CloudWatch に送信されるメトリクスを指定する正規表現です。
+ `dimensions` は、選択した各メトリクスの CloudWatch ディメンションとして使用されるラベルのリストです。
次の `metric_declaration` の例を参照してください。
```
"metric_declaration": [
{
"source_labels":[ "Service", "Namespace"],
"label_matcher":"(.*node-exporter.*|.*kube-dns.*);kube-system$",
"dimensions":[
["Service", "Namespace"]
],
"metric_selectors":[
"^coredns_dns_request_type_count_total$"
]
}
]
```
この例では、次の条件が満たされた場合にログイベントとして送信される埋め込みメトリクス形式セクションを設定します。
+ `Service` の値には `node-exporter` または `kube-dns` が含まれます。
+ `Namespace` の値は `kube-system` です。
+ Prometheus メトリクス `coredns_dns_request_type_count_total` には、`Service` ラベルおよび `Namespace` ラベルの両方が含まれます。
送信されるログイベントには、次の強調表示されたセクションが含まれます。
```
{
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"coredns_dns_request_type_count_total"
}
],
"Dimensions":[
[
"Namespace",
"Service"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
"Namespace":"kube-system",
"Service":"kube-dns",
"coredns_dns_request_type_count_total":2562,
"eks_amazonaws_com_component":"kube-dns",
"instance":"192.168.61.254:9153",
"job":"kubernetes-service-endpoints",
...
}
```
# Amazon ECS クラスターでの自動検出の詳細ガイド
Prometheus には、[](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config)で説明されているように、多数の動的なサービス検出メカニズムが用意されています。ただし、Amazon ECS の組み込みサービス検出はありません。CloudWatch エージェントはこのメカニズムを追加します。
Amazon ECS Prometheus サービス検出を有効にするときに、CloudWatch エージェントは定期的に Amazon ECS および Amazon EC2 フロントエンドに対して次の API コールを行い、ターゲット ECS クラスターで実行中の ECS タスクのメタデータを取得します。
```
EC2:DescribeInstances
ECS:ListTasks
ECS:ListServices
ECS:DescribeContainerInstances
ECS:DescribeServices
ECS:DescribeTasks
ECS:DescribeTaskDefinition
```
このメタデータは、ECS クラスター内の Prometheus ターゲットをスキャンするために CloudWatch エージェントによって使用されます。CloudWatch エージェントは、次の 3 つのサービス検出モードをサポートします。
+ コンテナドッカーのラベルベースのサービス検出
+ ECS タスク定義 ARN 正規表現ベースのサービス検出
+ ECS サービス名正規表現ベースのサービス検出
すべてのモードを一緒に使用することができます。CloudWatch エージェントは、`{private_ip}:{port}/{metrics_path}` に基づいて検出されたターゲットの重複を解除します。
検出されたターゲットはすべて、CloudWatch エージェントコンテナ内の `sd_result_file` 設定フィールドで指定された結果ファイルに書き込まれます。次に、結果ファイルの例を示します。
```
- targets:
- 10.6.1.95:32785
labels:
__metrics_path__: /metrics
ECS_PROMETHEUS_EXPORTER_PORT: "9406"
ECS_PROMETHEUS_JOB_NAME: demo-jar-ec2-bridge-dynamic
ECS_PROMETHEUS_METRICS_PATH: /metrics
InstanceType: t3.medium
LaunchType: EC2
SubnetId: subnet-123456789012
TaskDefinitionFamily: demo-jar-ec2-bridge-dynamic-port
TaskGroup: family:demo-jar-ec2-bridge-dynamic-port
TaskRevision: "7"
VpcId: vpc-01234567890
container_name: demo-jar-ec2-bridge-dynamic-port
job: demo-jar-ec2-bridge-dynamic
- targets:
- 10.6.3.193:9404
labels:
__metrics_path__: /metrics
ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_B: "9404"
ECS_PROMETHEUS_JOB_NAME: demo-tomcat-ec2-bridge-mapped-port
ECS_PROMETHEUS_METRICS_PATH: /metrics
InstanceType: t3.medium
LaunchType: EC2
SubnetId: subnet-123456789012
TaskDefinitionFamily: demo-tomcat-ec2-bridge-mapped-port
TaskGroup: family:demo-jar-tomcat-bridge-mapped-port
TaskRevision: "12"
VpcId: vpc-01234567890
container_name: demo-tomcat-ec2-bridge-mapped-port
job: demo-tomcat-ec2-bridge-mapped-port
```
この結果ファイルは、Prometheus ファイルベースのサービス検出と直接統合できます。Prometheus ファイルベースのサービス検出の詳細については、「[](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#file_sd_config)」を参照してください。
結果ファイルが `/tmp/cwagent_ecs_auto_sd.yaml` に書き込まれたとします。次の Prometheus スクレイプ設定はそれを消費します。
```
global:
scrape_interval: 1m
scrape_timeout: 10s
scrape_configs:
- job_name: cwagent-ecs-file-sd-config
sample_limit: 10000
file_sd_configs:
- files: [ "/tmp/cwagent_ecs_auto_sd.yaml" ]
```
CloudWatch エージェントは、検出されたターゲットに対して次の追加ラベルも追加します。
+ `container_name`
+ `TaskDefinitionFamily`
+ `TaskRevision`
+ `TaskGroup`
+ `StartedBy`
+ `LaunchType`
+ `job`
+ `__metrics_path__`
+ Docker のラベル
クラスターの起動タイプが EC2 の場合、次の 3 つのラベルが追加されます。
+ `InstanceType`
+ `VpcId`
+ `SubnetId`
**注記**
正規表現 `[a-zA-Z_][a-zA-Z0-9_]*` と一致しない Docker ラベルは除外されます。これは、Prometheus のマニュアルの「[構成ファイル](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#labelname)」 の `label_name` に記載されている Prometheus の規則と一致します。
## ECS サービス検出の設定例
このセクションでは、ECS サービスの検出を示す例について説明します。
**例 1**
```
"ecs_service_discovery": {
"sd_frequency": "1m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
}
}
```
この例では、Docker ラベルベースのサービス検出を有効にします。CloudWatch エージェントは、ECS タスクのメタデータを 1 分間に照会し、検出されたターゲットを CloudWatch エージェントコンテナ内の `/tmp/cwagent_ecs_auto_sd.yaml` ファイルに書き込みます。
`sd_port_label` セクションの `docker_label` のデフォルト値は `ECS_PROMETHEUS_EXPORTER_PORT` です。ECS タスク内の実行中のコンテナに `ECS_PROMETHEUS_EXPORTER_PORT` ドッカーラベルがある場合、CloudWatch エージェントはその値を `container port` として使用して、コンテナのすべての公開ポートをスキャンします。一致するものがある場合、マッピングされたホストポートとコンテナのプライベート IP を使用して、Prometheus エクスポータターゲットが `private_ip:host_port` の形式で構築されます。
`sd_metrics_path_label` セクションの `docker_label` のデフォルト値は `ECS_PROMETHEUS_METRICS_PATH` です。コンテナにこのドッカーラベルがある場合、その値は `__metrics_path__` として使用されます。コンテナにこのラベルがない場合は、デフォルト値 `/metrics` が使用されます。
`sd_job_name_label` セクションの `docker_label` のデフォルト値は `job` です。コンテナにこのドッカーラベルがある場合、その値はターゲットのラベルの 1 つとして追加され、Prometheus 設定で指定されたデフォルトのジョブ名が置き換えられます。このドッカーラベルの値は、CloudWatch Logs ロググループのログストリーム名として使用されます。
**例 2**
```
"ecs_service_discovery": {
"sd_frequency": "15s",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
"sd_port_label": "ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A",
"sd_job_name_label": "ECS_PROMETHEUS_JOB_NAME"
}
}
```
この例では、Docker ラベルベースのサービス検出を有効にします。CloudWatch エージェントは、ECS タスクのメタデータを 15 秒ごとに照会し、検出されたターゲットを CloudWatch エージェントコンテナ内の `/tmp/cwagent_ecs_auto_sd.yaml` ファイルに書き込みます。ドッカーラベルが `ECS_PROMETHEUS_EXPORTER_PORT_SUBSET_A` のコンテナがスキャンされます。ドッカーラベルが `ECS_PROMETHEUS_JOB_NAME` の値がジョブ名として使用されます。
**例 3**
```
"ecs_service_discovery": {
"sd_frequency": "5m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"task_definition_list": [
{
"sd_job_name": "java-prometheus",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9404; 9406",
"sd_task_definition_arn_pattern": ".*:task-definition/.*javajmx.*:[0-9]+"
},
{
"sd_job_name": "envoy-prometheus",
"sd_metrics_path": "/stats/prometheus",
"sd_container_name_pattern": "^envoy$",
"sd_metrics_ports": "9901",
"sd_task_definition_arn_pattern": ".*:task-definition/.*appmesh.*:23"
}
]
}
```
この例では、ECS タスク定義 ARN 正規表現ベースのサービス検出をイネーブルにします。CloudWatch エージェントは、ECS タスクのメタデータを 5 分ごとに照会し、検出されたターゲットを CloudWatch エージェントコンテナ内の `/tmp/cwagent_ecs_auto_sd.yaml` ファイルに書き込みます。
2 つのタスク定義 ARN 通常記述セクションが定義されています。
+ 最初のセクションでは、ECS タスク定義 ARN に `javajmx` が含まれる ECS タスクが、コンテナポートスキャン用にフィルタリングされます。これらの ECS タスク内のコンテナが 9404 または 9406 のコンテナポートを公開する場合、マップされたホストポートとコンテナのプライベート IP が Prometheus エクスポーターターゲットの作成に使用されます。`sd_metrics_path` の値は `__metrics_path__` から `/metrics` に設定します。したがって、CloudWatch エージェントは Prometheus メトリクスを `private_ip:host_port/metrics` からスクレイプし、スクレイプされたメトリクスは、`java-prometheus` ロググループ内の CloudWatch Logs の `/aws/ecs/containerinsights/cluster_name/prometheus` ログストリームに送信 されます。
+ 2 番目のセクションでは、ECS タスク定義 ARN に `appmesh` があり、`version` の `:23` がある ECS タスクが、コンテナポートスキャン用にフィルタリングされます。コンテナポートを `envoy` 上に公開する `9901` という名前のコンテナの場合、マッピングされたホストポートとコンテナのプライベート IP が Prometheus エクスポーターターゲットの作成に使用されます。これらの ECS タスク内の値は、9404 または 9406 のコンテナポートを公開し、マッピングされたホストポートとコンテナのプライベート IP が Prometheus エクスポーターターゲットの作成に使用されます。`sd_metrics_path` の値は `__metrics_path__` から `/stats/prometheus` に設定します。したがって、CloudWatch エージェントは `private_ip:host_port/stats/prometheus` から Prometheus メトリクスをスクレイプし、スクレイプされたメトリクスをロググループ `envoy-prometheus` 内の CloudWatch Logs の `/aws/ecs/containerinsights/cluster_name/prometheus` ログストリームに送信します。
**例 4**
```
"ecs_service_discovery": {
"sd_frequency": "5m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"service_name_list_for_tasks": [
{
"sd_job_name": "nginx-prometheus",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9113",
"sd_service_name_pattern": "^nginx-.*"
},
{
"sd_job_name": "haproxy-prometheus",
"sd_metrics_path": "/stats/metrics",
"sd_container_name_pattern": "^haproxy$",
"sd_metrics_ports": "8404",
"sd_service_name_pattern": ".*haproxy-service.*"
}
]
}
```
この例では、ECS サービス名正規表現ベースのサービス検出を有効にします。CloudWatch エージェントは、ECS サービスのメタデータを 5 分ごとに照会し、検出されたターゲットを CloudWatch エージェントコンテナ内の `/tmp/cwagent_ecs_auto_sd.yaml` ファイルに書き込みます。
2 つのサービス名正規表現セクションが定義されています。
+ 最初のセクションについて、正規表現 `^nginx-.*` に一致する名前を持つ ECS サービスに関連付けられた ECS タスクがコンテナポートスキャン用にフィルタリングされます。これらの ECS タスク内のコンテナが 9113 のコンテナポートを公開する場合、マップされたホストポートとコンテナのプライベート IP が Prometheus エクスポーターターゲットの作成に使用されます。`sd_metrics_path` の値は `__metrics_path__` から `/metrics` に設定します。したがって、CloudWatch エージェントは Prometheus メトリクスを `private_ip:host_port/metrics` からスクレイプし、スクレイプされたメトリクスは、`nginx-prometheus` ロググループ内の CloudWatch Logs の `/aws/ecs/containerinsights/cluster_name/prometheus` ログストリームに送信されます。
+ または、2 つ目のセクションについて、正規表現 `.*haproxy-service.*` に一致する名前を持つ ECS サービスに関連付けられた ECS タスクがコンテナポートスキャン用にフィルタリングされます。コンテナポートを 8404 上に公開する `haproxy` という名前のコンテナの場合、マッピングされたホストポートとコンテナのプライベート IP が Prometheus エクスポーターターゲットの作成に使用されます。`sd_metrics_path` の値は `__metrics_path__` から `/stats/metrics` に設定します。したがって、CloudWatch エージェントは Prometheus メトリクスを `private_ip:host_port/stats/metrics` からスクレイプし、スクレイプされたメトリクスは、`haproxy-prometheus` ロググループ内の CloudWatch Logs の `/aws/ecs/containerinsights/cluster_name/prometheus` ログストリームに送信されます。
**例 5**
```
"ecs_service_discovery": {
"sd_frequency": "1m30s",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
"docker_label": {
"sd_port_label": "MY_PROMETHEUS_EXPORTER_PORT_LABEL",
"sd_metrics_path_label": "MY_PROMETHEUS_METRICS_PATH_LABEL",
"sd_job_name_label": "MY_PROMETHEUS_METRICS_NAME_LABEL"
}
"task_definition_list": [
{
"sd_metrics_ports": "9150",
"sd_task_definition_arn_pattern": "*memcached.*"
}
]
}
```
この例では、両方の ECS サービス検出モードを有効にします。CloudWatch エージェントは、ECS タスクのメタデータを 90 秒ごとに照会し、検出されたターゲットを CloudWatch エージェントコンテナ内の `/tmp/cwagent_ecs_auto_sd.yaml` ファイルに書き込みます。
ドッカーベースのサービス検出設定の場合。
+ ドッカーラベル `MY_PROMETHEUS_EXPORTER_PORT_LABEL` 付きの ECS タスクは、Prometheus ポートスキャン用にフィルタリングされます。ターゲットの Prometheus コンテナポートは、ラベル `MY_PROMETHEUS_EXPORTER_PORT_LABEL` の値によって指定されます。
+ ドッカーラベル `MY_PROMETHEUS_EXPORTER_PORT_LABEL` の値は、`__metrics_path__` に使用されます。コンテナにこのドッカーラベルがない場合は、デフォルト値 `/metrics` が使用されます。
+ ドッカーラベル `MY_PROMETHEUS_EXPORTER_PORT_LABEL` の値は、ジョブラベルとして使用されます。コンテナにこのドッカーラベルがない場合は、Prometheus 設定で定義されたジョブ名が使用されます。
ECS タスク定義 ARN 正規表現ベースのサービス検出設定の場合。
+ ECS タスク定義 ARN `memcached` 内の ECS タスクは、コンテナポートスキャン用にフィルタリングされます。ターゲットの Prometheus コンテナポートは、`sd_metrics_ports` で定義されている 9150 です。デフォルトのメトリクスパス `/metrics` が使用されます。Prometheus 設定で定義されているジョブ名が使用されます。
# (オプション) Prometheus メトリクスのテストのためにコンテナ化された Amazon ECS のサンプルワークロードを設定する
CloudWatch Container Insights で Prometheus メトリクスのサポートをテストするには、次のコンテナ化されたワークロードを 1 つ以上設定できます。Prometheus をサポートする CloudWatch エージェントは、これらの各ワークロードからメトリクスを自動的に収集します。デフォルトで収集されるメトリクスを表示する方法については、「[CloudWatch エージェントにより収集される Prometheus メトリクス](ContainerInsights-Prometheus-metrics.md)」を参照してください。
**Topics**
+ [Amazon ECS クラスターの App Mesh ワークロードのサンプル](ContainerInsights-Prometheus-Sample-Workloads-ECS-appmesh.md)
+ [Amazon ECS クラスター用の Java/JMX ワークロードのサンプル](ContainerInsights-Prometheus-Sample-Workloads-ECS-javajmx.md)
+ [Amazon ECS クラスターの NGINX ワークロードのサンプル](ContainerInsights-Prometheus-Setup-nginx-ecs.md)
+ [Amazon ECS クラスターの NGINX Plus ワークロードのサンプル](ContainerInsights-Prometheus-Setup-nginx-plus-ecs.md)
+ [新しい Prometheus スクレイピングターゲットを追加するためのチュートリアル: Amazon ECS の Memcached](ContainerInsights-Prometheus-Setup-memcached-ecs.md)
+ [Amazon ECS Fargate 上の Redis OSS Prometheus メトリクスのスクレイピングに関するチュートリアル](ContainerInsights-Prometheus-Setup-redis-ecs.md)
# Amazon ECS クラスターの App Mesh ワークロードのサンプル
Amazon ECS のサンプル Prometheus ワークロードからメトリクスを収集するには、クラスターで Container Insights を実行している必要があります。Container Insights のインストールの詳細については、「[Amazon ECS での Container Insights のセットアップ](deploy-container-insights-ECS.md)」を参照してください。
まず、この[チュートリアル](https://github.com/aws/aws-app-mesh-examples/tree/main/examples/apps/colorapp#app-mesh-walkthrough-deploy-the-color-app-on-ecs)に従って、サンプルカラーアプリを Amazon ECS クラスターにデプロイします。完了したら、ポート 9901 に App Mesh Prometheus メトリクスが公開されます。
次に、以下のステップに従って、カラーアプリをインストールした同じ Amazon ECS クラスターに Prometheus モニターリングを使用して CloudWatch エージェントをインストールします。このセクションのステップでは、ブリッジネットワークモードで CloudWatch エージェントをインストールします。
チュートリアルで設定した環境変数 `ENVIRONMENT_NAME`、 `AWS_PROFILE`、`AWS_DEFAULT_REGION` は、次のステップでも使用されます。
**テスト用に Prometheus モニターリングを使用して CloudWatch エージェントをインストールするには**
1. 次のコマンドを入力して、CloudFormation テンプレートをダウンロードします。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
```
1. 次のコマンドを入力して、ネットワークモードを設定します。
```
export ECS_CLUSTER_NAME=${ENVIRONMENT_NAME}
export ECS_NETWORK_MODE=bridge
```
1. 次のコマンドを入力して、CloudFormation スタックを作成します。
```
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=${ECS_CLUSTER_NAME} \
ParameterKey=CreateIAMRoles,ParameterValue=True \
ParameterKey=ECSNetworkMode,ParameterValue=${ECS_NETWORK_MODE} \
ParameterKey=TaskRoleName,ParameterValue=CWAgent-Prometheus-TaskRole-${ECS_CLUSTER_NAME} \
ParameterKey=ExecutionRoleName,ParameterValue=CWAgent-Prometheus-ExecutionRole-${ECS_CLUSTER_NAME} \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
1. (オプション) CloudFormation スタックが作成されると、 `CREATE_COMPLETE` メッセージが表示されます。そのメッセージが表示される前にステータスを確認する場合は、次のコマンドを入力します。
```
aws cloudformation describe-stacks \
--stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--query 'Stacks[0].StackStatus' \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
**トラブルシューティング**
チュートリアルのステップでは、jq を使用して、 の出力結果を解析しますAWS CLI jq のインストールの詳細については、「[ jq](https://stedolan.github.io/jq/)」を参照してください。jq が正しく解析できるように、次のコマンドを使用して AWS CLI のデフォルトの出力形式を JSON に設定します。
```
$ aws configure
```
レスポンスが `Default output format` に到達したら、**json** と入力します 。
## Prometheus モニターリングを使用した CloudWatch エージェントのアンインストール
テストが終了したら、次のコマンドを入力し、CloudFormation スタックを削除して CloudWatch エージェントをアンインストールします。
```
aws cloudformation delete-stack \
--stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--region ${AWS_DEFAULT_REGION} \
--profile ${AWS_PROFILE}
```
# Amazon ECS クラスター用の Java/JMX ワークロードのサンプル
JMX Exporter は、Prometheus メトリクスとして JMX mBeans をスクレイプおよび公開できる公式の Prometheus エクスポーターです。詳細については、[prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter) を参照してください。
Prometheus をサポートする CloudWatch エージェントは、Amazon ECS クラスターのサービス検出設定に基づいて Java/JMX Prometheus メトリクスをスクレイプします。別のポートまたは metrics\$1path でメトリクスを公開するように JMX Exporter を設定できます。ポートまたはパスを変更する場合は、CloudWatch エージェント設定のデフォルトの `ecs_service_discovery` セクションを更新します。
Amazon ECS のサンプル Prometheus ワークロードからメトリクスを収集するには、クラスターで Container Insights を実行している必要があります。Container Insights のインストールの詳細については、「[Amazon ECS での Container Insights のセットアップ](deploy-container-insights-ECS.md)」を参照してください。
**Amazon ECS クラスターの Java/JMX サンプルワークロードをインストールするには**
1. これらのセクションのステップに従って、Docker イメージを作成します。
+ [例: Prometheus メトリクスを使用した Java Jar アプリケーション Docker イメージ](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md#ContainerInsights-Prometheus-Sample-Workloads-javajmx-jar)
+ [例: Prometheus メトリクスを使用した Apache Tomcat Docker イメージ](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md#ContainerInsights-Prometheus-Sample-Workloads-javajmx-tomcat)
1. Amazon ECS タスク定義ファイルに次の 2 つの docker ラベルを指定します。その後、クラスター内で Amazon ECS サービスまたは Amazon ECS タスクとしてタスク定義を実行できます。
+ Prometheus メトリクスが公開されている ContainerPort を指定するように`ECS_PROMETHEUS_EXPORTER_PORT` を設定します 。
+ `Java_EMF_Metrics` を `true` に設定します。CloudWatch エージェントは、このフラグを使用してログイベントに埋め込みメトリクス形式を生成します。
次に例を示します。
```
{
"family": "workload-java-ec2-bridge",
"taskRoleArn": "{{task-role-arn}}",
"executionRoleArn": "{{execution-role-arn}}",
"networkMode": "bridge",
"containerDefinitions": [
{
"name": "tomcat-prometheus-workload-java-ec2-bridge-dynamic-port",
"image": "your_docker_image_tag_for_tomcat_with_prometheus_metrics",
"portMappings": [
{
"hostPort": 0,
"protocol": "tcp",
"containerPort": 9404
}
],
"dockerLabels": {
"ECS_PROMETHEUS_EXPORTER_PORT": "9404",
"Java_EMF_Metrics": "true"
}
}
],
"requiresCompatibilities": [
"EC2" ],
"cpu": "256",
"memory": "512"
}
```
CloudFormation テンプレートの CloudWatch エージェントのデフォルト設定では、docker のラベルベースのサービス検出とタスク定義の ARN ベースのサービス検出の両方が有効になります。これらのデフォルト設定を表示するには、「[CloudWatch エージェント YAML 設定ファイル](https://github.com/aws-samples/amazon-cloudwatch-container-insights/blob/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml#L65)」の 65 行目を参照してください。`ECS_PROMETHEUS_EXPORTER_PORT` ラベル付きのコンテナは、Prometheus スクレイピング用に指定されたコンテナポートに基づいて自動検出されます。
CloudWatch エージェントのデフォルト設定には、同じファイルの 112 行目に Java/JMX の `metric_declaration` 設定もあります。ターゲットコンテナのすべての docker ラベルは、Prometheus メトリクスに追加ラベルとして追加され、CloudWatch Logs に送信されます。docker ラベル `Java_EMF_Metrics=“true”` 付きの Java/JMX コンテナの場合、埋め込みメトリクス形式が生成されます。
# Amazon ECS クラスターの NGINX ワークロードのサンプル
NGINX Prometheus エクスポーターは、NGINX データを Prometheus のメトリクスとしてスクレイピングして公開できます。この例では、エクスポーターを Amazon ECS 用の NGINX リバースプロキシサービスと連動させて使用します。
NGINX Prometheus エクスポーターの詳細については、GitHub の [nginx-prometheus-exporter](https://github.com/nginxinc/nginx-prometheus-exporter) をご参照ください。NGINX リバースプロキシの詳細については、GitHub の [ecs-nginx-reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy)をご参照ください。
Prometheus をサポートする CloudWatch エージェントは、Amazon ECS クラスターのサービス検出設定に基づいて NGINX Prometheus メトリクスをスクレイプします。別のポートまたはパスでメトリクスを公開するように NGINX Prometheus Exporter を設定できます。ポートまたはパスを変更する場合は、CloudWatch エージェント設定ファイルの `ecs_service_discovery` セクションを更新します。
## Amazon ECS クラスター用の NGINX リバースプロキシサンプルワークロードをインストールする
NGINX リバースプロキシサンプルワークロードをインストールするには、次の手順を実行します。
### Docker イメージを作成する
**NGINX リバースプロキシサンプルワークロード用の Docker イメージを作成するには**
1. NGINX リバースプロキシリポジトリから次のフォルダをダウンロードします: [ https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/)。
1. `app` ディレクトリを検索し、そのディレクトリからイメージを作成します。
```
docker build -t web-server-app ./path-to-app-directory
```
1. NGINX 用のカスタムイメージを作成します。まず、次の 2 つのファイルを含むディレクトリを作成します。
+ サンプル Dockerfile:
```
FROM nginx
COPY nginx.conf /etc/nginx/nginx.conf
```
+ [https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/) から変更された `nginx.conf` ファイル:
```
events {
worker_connections 768;
}
http {
# Nginx will handle gzip compression of responses from the app server
gzip on;
gzip_proxied any;
gzip_types text/plain application/json;
gzip_min_length 1000;
server{
listen 8080;
location /stub_status {
stub_status on;
}
}
server {
listen 80;
# Nginx will reject anything not matching /api
location /api {
# Reject requests with unsupported HTTP method
if ($request_method !~ ^(GET|POST|HEAD|OPTIONS|PUT|DELETE)$) {
return 405;
}
# Only requests matching the whitelist expectations will
# get sent to the application server
proxy_pass http://app:3000;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_cache_bypass $http_upgrade;
}
}
}
```
**注記**
`stub_status` は、`nginx-prometheus-exporter` がメトリクスをスクレイピングするように設定されているのと同じポートで有効にする必要があります。このタスク定義例では、`nginx-prometheus-exporter` がポート 8080 からメトリクスをスクレイピングするように設定されています。
1. 新しいディレクトリのファイルからイメージを作成します。
```
docker build -t nginx-reverse-proxy ./path-to-your-directory
```
1. 後で使用するために、新しいイメージをイメージリポジトリにアップロードします。
### Amazon ECS で NGINX とウェブサーバーアプリを実行するタスク定義を作成します。
次に、タスク定義を設定します。
このタスク定義により、NGINX Prometheus メトリクスの収集とエクスポートが可能になります。NGINX コンテナは、アプリからの入力を追跡し、(`nginx.conf` で設定されているとおり) そのデータをポート 8080 に公開します。NGINX Prometheus エクスポーターコンテナは、CloudWatch で使用するために、これらのメトリクスをスクレイピングし、ポート 9113 に投稿します。
**NGINX サンプル Amazon ECS ワークロードのタスク定義を設定するには**
1. 次の内容でタスク定義 JSON ファイルを作成します。*your-customized-nginx-iamge* をカスタマイズした NGINX イメージのイメージ URI に置き換え、*your-web-server-app-image* をウェブサーバーアプリイメージのイメージ URI に置き換えます。
```
{
"containerDefinitions": [
{
"name": "nginx",
"image": "your-customized-nginx-image",
"memory": 256,
"cpu": 256,
"essential": true,
"portMappings": [
{
"containerPort": 80,
"protocol": "tcp"
}
],
"links": [
"app"
]
},
{
"name": "app",
"image": "your-web-server-app-image",
"memory": 256,
"cpu": 256,
"essential": true
},
{
"name": "nginx-prometheus-exporter",
"image": "docker.io/nginx/nginx-prometheus-exporter:0.8.0",
"memory": 256,
"cpu": 256,
"essential": true,
"command": [
"-nginx.scrape-uri",
"http://nginx:8080/stub_status"
],
"links":[
"nginx"
],
"portMappings":[
{
"containerPort": 9113,
"protocol": "tcp"
}
]
}
],
"networkMode": "bridge",
"placementConstraints": [],
"family": "nginx-sample-stack"
}
```
1. 次のコマンドを入力して、タスク定義を登録します。
```
aws ecs register-task-definition --cli-input-json file://path-to-your-task-definition-json
```
1. 次のコマンドを入力して、タスクを実行するサービスを作成します。
サービス名は変更しないでください。CloudWatch エージェントサービスは、タスクを開始したサービスの名前パターンを使用してタスクを検索する設定を使用して実行します。例えば、このコマンドによって起動されたタスクを CloudWatch エージェントが検出するには、`sd_service_name_pattern` の値を `^nginx-service$` に指定します。次のセクションでは、詳細を説明します。
```
aws ecs create-service \
--cluster your-cluster-name \
--service-name nginx-service \
--task-definition nginx-sample-stack:1 \
--desired-count 1
```
### NGINX Prometheus メトリクスをスクレイプするように CloudWatch エージェントを設定する
最後のステップでは、NGINX メトリクスをスクレイピングするように CloudWatch エージェントを設定します。この例では、CloudWatch エージェントはサービス名パターンとポート 9113 を使用してタスクを検出します。このポートでは、エクスポーターは NGINX の Prometheus メトリクスを公開します。タスクが検出され、メトリクスが使用可能になると、CloudWatch エージェントは、ログストリーム **nginx-prometheus-exporter** への収集したメトリクスの投稿を開始します。
**NGINX メトリクスをスクレイピングするように CloudWatch エージェントを設定するには**
1. 次のコマンドを入力して、必要な YAML ファイルの最新バージョンをダウンロードします。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
```
1. テキストエディタでファイルを開き、`value` セクションの `resource:CWAgentConfigSSMParameter` キーにある完全な CloudWatch エージェント設定を見つけます。その後、`ecs_service_discovery` セクションで、次の `service_name_list_for_tasks` セクションを追加します。
```
"service_name_list_for_tasks": [
{
"sd_job_name": "nginx-prometheus-exporter",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9113",
"sd_service_name_pattern": "^nginx-service$"
}
],
```
1. 同じファイルで、`metric_declaration` セクションに次のセクションを追加して、NGINX メトリクスを許可します。デフォルトのインデントパターンに従ってください。
```
{
"source_labels": ["job"],
"label_matcher": ".*nginx.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]],
"metric_selectors": [
"^nginx_.*$"
]
},
```
1. このクラスターにまだ CloudWatch エージェントがデプロイされていない場合は、ステップ 8 に進みます。
AWS CloudFormation を使用することによって Amazon ECS クラスターに CloudWatch エージェントを既にデプロイしている場合は、次のコマンドを入力して変更セットを作成できます。
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name nginx-scraping-support
```
1. [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/) で CloudFormation コンソール を開きます。
1. 新しく作成されたチェンジセット **nginx-scraping-support** を確認します。**CWAgentConfigSSMParameter** リソースに適用された変更が 1 つ表示されます。次のコマンドを入力して、変更セットを実行し、CloudWatch エージェントタスクを再起動します。
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. 10 秒ほど待ってから、次のコマンドを入力します。
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. クラスターの Prometheus メトリクス収集を使用して CloudWatch エージェントを初めてインストールする場合は、次のコマンドを入力します。
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
## NGINX メトリクスとログの表示
これで、収集されている NGINX メトリクスを表示できるようになりました。
**サンプル NGINX ワークロードのメトリクスを表示するには**
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. クラスターが実行されているリージョンにおいて、左のナビゲーションペインで [**Metrics**] (メトリクス) を選択します。**ContainerInsights/Prometheus** 名前空間を検索して、メトリクスを確認します。
1. CloudWatch Logs イベントを表示するには、ナビゲーションペインで [**Log Groups (ロググループ)**] を選択します。イベントは、ログストリーム *nginx-prometheus-exporter* のロググループ **/aws/containerinsights/*your\$1cluster\$1name*/prometheus** にあります。
# Amazon ECS クラスターの NGINX Plus ワークロードのサンプル
NGINX Plus は NGINX の商用バージョンです。これを使用するには、ライセンスが必要です。詳細については、「[NGINX Plus](https://www.nginx.com/products/nginx/)」をご参照ください。
NGINX Prometheus エクスポーターは、NGINX データを Prometheus のメトリクスとしてスクレイピングして公開できます。この例では、エクスポーターを Amazon ECS 用の NGINX Plus リバースプロキシサービスと連動させて使用します。
NGINX Prometheus エクスポーターの詳細については、GitHub の [nginx-prometheus-exporter](https://github.com/nginxinc/nginx-prometheus-exporter) をご参照ください。NGINX リバースプロキシの詳細については、GitHub の [ecs-nginx-reverse-proxy](https://github.com/awslabs/ecs-nginx-reverse-proxy)をご参照ください。
Prometheus をサポートする CloudWatch エージェントは、Amazon ECS クラスターのサービス検出設定に基づいて NGINX Plus Prometheus メトリクスをスクレイプします。別のポートまたはパスでメトリクスを公開するように NGINX Prometheus Exporter を設定できます。ポートまたはパスを変更する場合は、CloudWatch エージェント設定ファイルの `ecs_service_discovery` セクションを更新します。
## Amazon ECS クラスター用の NGINX Plus リバースプロキシサンプルワークロードをインストールする
NGINX リバースプロキシサンプルワークロードをインストールするには、次の手順を実行します。
### Docker イメージを作成する
**NGINX Plus リバースプロキシサンプルワークロード用の Docker イメージを作成するには**
1. NGINX リバースプロキシリポジトリから次のフォルダをダウンロードします: [ https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/)。
1. `app` ディレクトリを検索し、そのディレクトリからイメージを作成します。
```
docker build -t web-server-app ./path-to-app-directory
```
1. NGINX Plus 用のカスタムイメージを作成します。NGINX Plus のイメージを作成する前に、ライセンスされている NGINX Plus の `nginx-repo.key` という名前のキーと SSL 証明書 `nginx-repo.crt` を取得する必要があります。ディレクトリを作成し、その中に `nginx-repo.key` ファイルと `nginx-repo.crt` ファイルを格納します。
作成したディレクトリに、次の 2 つのファイルを作成します。
+ 以下の内容を含むサンプル Dockerfile。この docker ファイルは [https://docs.nginx.com/nginx/admin-guide/installing-nginx/installing-nginx-docker/\$1docker\$1plus\$1image](https://docs.nginx.com/nginx/admin-guide/installing-nginx/installing-nginx-docker/#docker_plus_image) で提供されているサンプルファイルから採用されています。実行する重要な変更は、次のステップで作成される `nginx.conf` と呼ばれる別個のファイルをロードすることです。
```
FROM debian:buster-slim
LABEL maintainer="NGINX Docker Maintainers “
# Define NGINX versions for NGINX Plus and NGINX Plus modules
# Uncomment this block and the versioned nginxPackages block in the main RUN
# instruction to install a specific release
# ENV NGINX_VERSION 21
# ENV NJS_VERSION 0.3.9
# ENV PKG_RELEASE 1~buster
# Download certificate and key from the customer portal (https://cs.nginx.com (https://cs.nginx.com/))
# and copy to the build context
COPY nginx-repo.crt /etc/ssl/nginx/
COPY nginx-repo.key /etc/ssl/nginx/
# COPY nginx.conf /etc/ssl/nginx/nginx.conf
RUN set -x \
# Create nginx user/group first, to be consistent throughout Docker variants
&& addgroup --system --gid 101 nginx \
&& adduser --system --disabled-login --ingroup nginx --no-create-home --home /nonexistent --gecos "nginx user" --shell /bin/false --uid 101 nginx \
&& apt-get update \
&& apt-get install --no-install-recommends --no-install-suggests -y ca-certificates gnupg1 \
&& \
NGINX_GPGKEY=573BFD6B3D8FBC641079A6ABABF5BD827BD9BF62; \
found=''; \
for server in \
ha.pool.sks-keyservers.net (http://ha.pool.sks-keyservers.net/) \
hkp://keyserver.ubuntu.com:80 \
hkp://p80.pool.sks-keyservers.net:80 \
pgp.mit.edu (http://pgp.mit.edu/) \
; do \
echo "Fetching GPG key $NGINX_GPGKEY from $server"; \
apt-key adv --keyserver "$server" --keyserver-options timeout=10 --recv-keys "$NGINX_GPGKEY" && found=yes && break; \
done; \
test -z "$found" && echo >&2 "error: failed to fetch GPG key $NGINX_GPGKEY" && exit 1; \
apt-get remove --purge --auto-remove -y gnupg1 && rm -rf /var/lib/apt/lists/* \
# Install the latest release of NGINX Plus and/or NGINX Plus modules
# Uncomment individual modules if necessary
# Use versioned packages over defaults to specify a release
&& nginxPackages=" \
nginx-plus \
# nginx-plus=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-xslt \
# nginx-plus-module-xslt=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-geoip \
# nginx-plus-module-geoip=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-image-filter \
# nginx-plus-module-image-filter=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-perl \
# nginx-plus-module-perl=${NGINX_VERSION}-${PKG_RELEASE} \
# nginx-plus-module-njs \
# nginx-plus-module-njs=${NGINX_VERSION}+${NJS_VERSION}-${PKG_RELEASE} \
" \
&& echo "Acquire::https::plus-pkgs.nginx.com::Verify-Peer \"true\";" >> /etc/apt/apt.conf.d/90nginx \
&& echo "Acquire::https::plus-pkgs.nginx.com::Verify-Host \"true\";" >> /etc/apt/apt.conf.d/90nginx \
&& echo "Acquire::https::plus-pkgs.nginx.com::SslCert \"/etc/ssl/nginx/nginx-repo.crt\";" >> /etc/apt/apt.conf.d/90nginx \
&& echo "Acquire::https::plus-pkgs.nginx.com::SslKey \"/etc/ssl/nginx/nginx-repo.key\";" >> /etc/apt/apt.conf.d/90nginx \
&& printf "deb https://plus-pkgs.nginx.com/debian buster nginx-plus\n" > /etc/apt/sources.list.d/nginx-plus.list \
&& apt-get update \
&& apt-get install --no-install-recommends --no-install-suggests -y \
$nginxPackages \
gettext-base \
curl \
&& apt-get remove --purge --auto-remove -y && rm -rf /var/lib/apt/lists/* /etc/apt/sources.list.d/nginx-plus.list \
&& rm -rf /etc/apt/apt.conf.d/90nginx /etc/ssl/nginx
# Forward request logs to Docker log collector
RUN ln -sf /dev/stdout /var/log/nginx/access.log \
&& ln -sf /dev/stderr /var/log/nginx/error.log
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 80
STOPSIGNAL SIGTERM
CMD ["nginx", "-g", "daemon off;"]
```
+ [https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/nginx](https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy/nginx) から変更された `nginx.conf` ファイル:
```
events {
worker_connections 768;
}
http {
# Nginx will handle gzip compression of responses from the app server
gzip on;
gzip_proxied any;
gzip_types text/plain application/json;
gzip_min_length 1000;
upstream backend {
zone name 10m;
server app:3000 weight=2;
server app2:3000 weight=1;
}
server{
listen 8080;
location /api {
api write=on;
}
}
match server_ok {
status 100-599;
}
server {
listen 80;
status_zone zone;
# Nginx will reject anything not matching /api
location /api {
# Reject requests with unsupported HTTP method
if ($request_method !~ ^(GET|POST|HEAD|OPTIONS|PUT|DELETE)$) {
return 405;
}
# Only requests matching the whitelist expectations will
# get sent to the application server
proxy_pass http://backend;
health_check uri=/lorem-ipsum match=server_ok;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_cache_bypass $http_upgrade;
}
}
}
```
1. 新しいディレクトリのファイルからイメージを作成します。
```
docker build -t nginx-plus-reverse-proxy ./path-to-your-directory
```
1. 後で使用するために、新しいイメージをイメージリポジトリにアップロードします。
### Amazon ECS で NGINX Plus とウェブサーバーアプリを実行するタスク定義を作成します。
次に、タスク定義を設定します。
このタスク定義により、NGINX Plus Prometheus メトリクスの収集とエクスポートが可能になります。NGINX コンテナは、アプリからの入力を追跡し、(`nginx.conf` で設定されているとおり) そのデータをポート 8080 に公開します。NGINX Prometheus エクスポーターコンテナは、CloudWatch で使用するために、これらのメトリクスをスクレイピングし、ポート 9113 に投稿します。
**NGINX サンプル Amazon ECS ワークロードのタスク定義を設定するには**
1. 次の内容でタスク定義 JSON ファイルを作成します。*your-customized-nginx-plus-image* をカスタマイズした NGINX Plus イメージのイメージ URI に置き換え、*your-web-server-app-image* をウェブサーバーアプリイメージのイメージ URI に置き換えます。
```
{
"containerDefinitions": [
{
"name": "nginx",
"image": "your-customized-nginx-plus-image",
"memory": 256,
"cpu": 256,
"essential": true,
"portMappings": [
{
"containerPort": 80,
"protocol": "tcp"
}
],
"links": [
"app",
"app2"
]
},
{
"name": "app",
"image": "your-web-server-app-image",
"memory": 256,
"cpu": 128,
"essential": true
},
{
"name": "app2",
"image": "your-web-server-app-image",
"memory": 256,
"cpu": 128,
"essential": true
},
{
"name": "nginx-prometheus-exporter",
"image": "docker.io/nginx/nginx-prometheus-exporter:0.8.0",
"memory": 256,
"cpu": 256,
"essential": true,
"command": [
"-nginx.plus",
"-nginx.scrape-uri",
"http://nginx:8080/api"
],
"links":[
"nginx"
],
"portMappings":[
{
"containerPort": 9113,
"protocol": "tcp"
}
]
}
],
"networkMode": "bridge",
"placementConstraints": [],
"family": "nginx-plus-sample-stack"
}
```
1. タスク定義を登録します。
```
aws ecs register-task-definition --cli-input-json file://path-to-your-task-definition-json
```
1. 次のコマンドを入力して、タスクを実行するサービスを作成します。
```
aws ecs create-service \
--cluster your-cluster-name \
--service-name nginx-plus-service \
--task-definition nginx-plus-sample-stack:1 \
--desired-count 1
```
サービス名は変更しないでください。CloudWatch エージェントサービスは、タスクを開始したサービスの名前パターンを使用してタスクを検索する設定を使用して実行します。例えば、このコマンドによって起動されたタスクを CloudWatch エージェントが検出するには、`sd_service_name_pattern` の値を `^nginx-plus-service$` に指定します。次のセクションでは、詳細を説明します。
### NGINX Plus Prometheus メトリクスをスクレイプするように CloudWatch エージェントを設定する
最後のステップでは、NGINX メトリクスをスクレイピングするように CloudWatch エージェントを設定します。この例では、CloudWatch エージェントはサービス名パターンとポート 9113 を使用してタスクを検出します。このポートでは、エクスポーターは NGINX の Prometheus メトリクスを公開します。タスクが検出され、メトリクスが使用可能になると、CloudWatch エージェントは、ログストリーム **nginx-prometheus-exporter** への収集したメトリクスの投稿を開始します。
**NGINX メトリクスをスクレイピングするように CloudWatch エージェントを設定するには**
1. 次のコマンドを入力して、必要な YAML ファイルの最新バージョンをダウンロードします。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml
```
1. テキストエディタでファイルを開き、`value` セクションの `resource:CWAgentConfigSSMParameter` キーにある完全な CloudWatch エージェント設定を見つけます。その後、`ecs_service_discovery` セクションで、次の `service_name_list_for_tasks` セクションを追加します。
```
"service_name_list_for_tasks": [
{
"sd_job_name": "nginx-plus-prometheus-exporter",
"sd_metrics_path": "/metrics",
"sd_metrics_ports": "9113",
"sd_service_name_pattern": "^nginx-plus.*"
}
],
```
1. 同じファイルで、`metric_declaration` セクションに次のセクションを追加して、NGINX Plus メトリクスを許可します。デフォルトのインデントパターンに従ってください。
```
{
"source_labels": ["job"],
"label_matcher": "^nginx-plus.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]],
"metric_selectors": [
"^nginxplus_connections_accepted$",
"^nginxplus_connections_active$",
"^nginxplus_connections_dropped$",
"^nginxplus_connections_idle$",
"^nginxplus_http_requests_total$",
"^nginxplus_ssl_handshakes$",
"^nginxplus_ssl_handshakes_failed$",
"^nginxplus_up$",
"^nginxplus_upstream_server_health_checks_fails$"
]
},
{
"source_labels": ["job"],
"label_matcher": "^nginx-plus.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName", "upstream"]],
"metric_selectors": [
"^nginxplus_upstream_server_response_time$"
]
},
{
"source_labels": ["job"],
"label_matcher": "^nginx-plus.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName", "code"]],
"metric_selectors": [
"^nginxplus_upstream_server_responses$",
"^nginxplus_server_zone_responses$"
]
},
```
1. このクラスターにまだ CloudWatch エージェントがデプロイされていない場合は、ステップ 8 に進みます。
AWS CloudFormation を使用することによって Amazon ECS クラスターに CloudWatch エージェントを既にデプロイしている場合は、次のコマンドを入力して変更セットを作成できます。
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name nginx-plus-scraping-support
```
1. [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/) で CloudFormation コンソール を開きます。
1. 新しく作成されたチェンジセット **nginx-plus-scraping-support** を確認します。**CWAgentConfigSSMParameter** リソースに適用された変更が 1 つ表示されます。次のコマンドを入力して、変更セットを実行し、CloudWatch エージェントタスクを再起動します。
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. 10 秒ほど待ってから、次のコマンドを入力します。
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. クラスターの Prometheus メトリクス収集を使用して CloudWatch エージェントを初めてインストールする場合は、次のコマンドを入力します。
```
ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
## NGINX Plus メトリクスとログの表示
これで、収集されている NGINX Plus メトリクスを表示できるようになりました。
**サンプル NGINX ワークロードのメトリクスを表示するには**
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. クラスターが実行されているリージョンにおいて、左のナビゲーションペインで [**Metrics**] (メトリクス) を選択します。**ContainerInsights/Prometheus** 名前空間を検索して、メトリクスを確認します。
1. CloudWatch Logs イベントを表示するには、ナビゲーションペインで [**Log Groups (ロググループ)**] を選択します。イベントは、ログストリーム *nginx-plus-prometheus-exporter* のロググループ **/aws/containerinsights/*your\$1cluster\$1name*/prometheus** にあります。
# 新しい Prometheus スクレイピングターゲットを追加するためのチュートリアル: Amazon ECS の Memcached
このチュートリアルでは、EC2 起動タイプの Amazon ECS クラスター上のサンプル Memcached アプリケーションの Prometheus メトリクスをスクレイプする実践的な紹介を提供します。Memcached Prometheus エクスポーターのターゲットは、ECS タスク定義ベースのサービス検出によって CloudWatch エージェントによって自動検出されます。
Memcached は、汎用分散メモリキャッシュシステムです。多くの場合、データおよびオブジェクトを RAM にキャッシュし、外部データソース (データベースや API など) を読み取る回数を減らすことで、動的なデータベース駆動のウェブサイトを高速化するために使用されます。詳細については、「[Memcached とは](https://www.memcached.org/)」を参照してください。
[ memchached\$1exporter](https://github.com/prometheus/memcached_exporter) (Apache License 2.0) は、Prometheus 公式エクスポーターの一つです。デフォルトでは、memcache\$1exporter は `/metrics.` のポート 0.0.0.0:9150 でサービスを提供します。
このチュートリアルでは、次の 2 つの Docker ハブリポジトリの Docker イメージを使用します。
+ [Memcached](https://hub.docker.com/_/memcached?tab=description)
+ [ prom/memcached-exporter](https://hub.docker.com/r/prom/memcached-exporter/)
**前提条件**
Amazon ECS のサンプル Prometheus ワークロードからメトリクスを収集するには、クラスターで Container Insights を実行している必要があります。Container Insights のインストールの詳細については、「[Amazon ECS での Container Insights のセットアップ](deploy-container-insights-ECS.md)」を参照してください。
**Topics**
+ [Amazon ECS EC2 クラスター環境変数を設定する](#ContainerInsights-Prometheus-Setup-memcached-ecs-environment)
+ [Memcached サンプルワークロードのインストール](#ContainerInsights-Prometheus-Setup-memcached-ecs-install-workload)
+ [Memcached Prometheus メトリクスをスクレイプするように CloudWatch エージェントを設定する](#ContainerInsights-Prometheus-Setup-memcached-ecs-agent)
+ [Memcached メトリクスの表示](#ContainerInsights-Prometheus-ECS-memcached-view)
## Amazon ECS EC2 クラスター環境変数を設定する
**Amazon ECS EC2 クラスター環境変数を設定するには**
1. まだの場合は、Amazon ECS CLI をインストールしてください。詳細については、「[Amazon ECS CLI のインストール](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI_installation.html)」を参照してください。
1. 新しい Amazon ECS クラスター名とリージョンを設定します。次に例を示します。
```
ECS_CLUSTER_NAME=ecs-ec2-memcached-tutorial
AWS_DEFAULT_REGION=ca-central-1
```
1. (オプション) Memcached サンプルワークロードと CloudWatch エージェントをインストールする EC2 起動タイプの Amazon ECS クラスターがまだない場合は、次のコマンドを入力してクラスターを作成できます。
```
ecs-cli up --capability-iam --size 1 \
--instance-type t3.medium \
--cluster $ECS_CLUSTER_NAME \
--region $AWS_REGION
```
このコマンドの予想される結果は次のとおりです。
```
WARN[0000] You will not be able to SSH into your EC2 instances without a key pair.
INFO[0000] Using recommended Amazon Linux 2 AMI with ECS Agent 1.44.4 and Docker version 19.03.6-ce
INFO[0001] Created cluster cluster=ecs-ec2-memcached-tutorial region=ca-central-1
INFO[0002] Waiting for your cluster resources to be created...
INFO[0002] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS
INFO[0063] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS
INFO[0124] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS
VPC created: vpc-xxxxxxxxxxxxxxxxx
Security Group created: sg-xxxxxxxxxxxxxxxxx
Subnet created: subnet-xxxxxxxxxxxxxxxxx
Subnet created: subnet-xxxxxxxxxxxxxxxxx
Cluster creation succeeded.
```
## Memcached サンプルワークロードのインストール
**Prometheus メトリクスを公開する Memcached サンプルワークロードをインストールするには**
1. 次のコマンドを入力して、Memcached CloudFormation テンプレートをダウンロードします。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_traffic/memcached/memcached-traffic-sample.yaml
```
1. 次のコマンドを入力して、Memcached 用に作成する IAM ロール名を設定します。
```
MEMCACHED_ECS_TASK_ROLE_NAME=memcached-prometheus-demo-ecs-task-role-name
MEMCACHED_ECS_EXECUTION_ROLE_NAME=memcached-prometheus-demo-ecs-execution-role-name
```
1. 次のコマンドを入力して、Memcached サンプルワークロードをインストールします。このサンプルでは、ワークロードを `host` ネットワークモードでインストールします。
```
MEMCACHED_ECS_NETWORK_MODE=host
aws cloudformation create-stack --stack-name Memcached-Prometheus-Demo-ECS-$ECS_CLUSTER_NAME-EC2-$MEMCACHED_ECS_NETWORK_MODE \
--template-body file://memcached-traffic-sample.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=ECSNetworkMode,ParameterValue=$MEMCACHED_ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$MEMCACHED_ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$MEMCACHED_ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
CloudFormation スタックは、次の 4 つのリソースを作成します。
+ 1 つの ECS タスクロール
+ 1 つの ECS タスク実行ロール
+ 1 つの Memcached タスク定義
+ 1 つの Memcached サービス
Memcached タスク定義では、次の 2 つのコンテナが定義されています。
+ プライマリコンテナは単純な Memcached アプリケーションを実行し、アクセス用にポート 11211 を開きます。
+ もう一方のコンテナは Redis OSS エクスポータープロセスを実行して、ポート 9150 の Prometheus メトリクスを公開します。これは、CloudWatch エージェントによって検出され、スクレイプされるコンテナです。
## Memcached Prometheus メトリクスをスクレイプするように CloudWatch エージェントを設定する
**Memcached Prometheus メトリクスをスクレイプするように CloudWatch エージェントを設定するには**
1. 次のコマンドを入力して、`cwagent-ecs-prometheus-metric-for-awsvpc.yaml` の最新バージョンをダウンロードします。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
```
1. テキストエディタでファイルを開き、`value` セクションの `resource:CWAgentConfigSSMParameter` キーの背後にある完全な CloudWatch エージェント設定を見つけます。
次に、`ecs_service_discovery` セクションで、次の設定を `task_definition_list` セクションに追加します。
```
{
"sd_job_name": "ecs-memcached",
"sd_metrics_ports": "9150",
"sd_task_definition_arn_pattern": ".*:task-definition/memcached-prometheus-demo.*:[0-9]+"
},
```
`metric_declaration` セクションの場合、デフォルト設定では Memcached メトリクスを許可しません。Memcached メトリクスを許可するには、次のセクションを追加します。デフォルトのインデントパターンに従ってください。
```
{
"source_labels": ["container_name"],
"label_matcher": "memcached-exporter-.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily"]],
"metric_selectors": [
"^memcached_current_(bytes|items|connections)$",
"^memcached_items_(reclaimed|evicted)_total$",
"^memcached_(written|read)_bytes_total$",
"^memcached_limit_bytes$",
"^memcached_commands_total$"
]
},
{
"source_labels": ["container_name"],
"label_matcher": "memcached-exporter-.*",
"dimensions": [["ClusterName", "TaskDefinitionFamily","status","command"], ["ClusterName", "TaskDefinitionFamily","command"]],
"metric_selectors": [
"^memcached_commands_total$"
]
},
```
1. CloudFormation によって Amazon ECS クラスターに CloudWatch エージェントを既にデプロイしている場合は、次のコマンドを入力して変更セットを作成できます。
```
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name memcached-scraping-support
```
1. [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/) で CloudFormation コンソール を開きます。
1. 新しく作成された変更セット `memcached-scraping-support` を確認します。`CWAgentConfigSSMParameter` リソースに 1 つの変更が適用されていることがわかります。次のコマンドを入力して、変更セットを実行し、CloudWatch エージェントタスクを再起動します。
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. 10 秒ほど待ってから、次のコマンドを入力します。
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```
1. クラスターの Prometheus メトリクス収集を使用して CloudWatch エージェントを初めてインストールする場合は、次のコマンドを入力します。
```
ECS_NETWORK_MODEE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION
```
## Memcached メトリクスの表示
このチュートリアルでは、次のメトリクスを CloudWatch の **ECS/ContainerInsights/Prometheus** 名前空間に送信します。CloudWatch コンソールを使用して、その名前空間のメトリクスを表示できます。
| メトリクス名 | ディメンション |
| --- | --- |
| `memcached_current_items` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_current_connections` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_limit_bytes` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_current_bytes` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_written_bytes_total` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_read_bytes_total` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_items_evicted_total` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_items_reclaimed_total` | `ClusterName`, `TaskDefinitionFamily` |
| `memcached_commands_total` | `ClusterName`, `TaskDefinitionFamily` `ClusterName`、TaskDefinitionFamily、コマンド `ClusterName`、TaskDefinitionFamily、ステータス、コマンド |
**注記**
**コマンド** ディメンションの値には `delete`、`get`、`cas`、`set`、`decr`、`touch`、`incr`、または `flush` を指定できます。
**ステータス** ディメンションの値は `hit`、`miss`、または `badval`です。
Memcached Prometheus メトリクスの CloudWatch ダッシュボードを作成することもできます。
**Memcached Prometheus メトリクスのダッシュボードを作成するには**
1. 環境変数を作成し、以下の値をデプロイに合わせて置き換えます。
```
DASHBOARD_NAME=your_memcached_cw_dashboard_name
ECS_TASK_DEF_FAMILY=memcached-prometheus-demo-$ECS_CLUSTER_NAME-EC2-$MEMCACHED_ECS_NETWORK_MOD
```
1. 次のコマンドを入力して、ダッシュボードを作成します。
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_cloudwatch_dashboards/memcached/cw_dashboard_memcached.json \
| sed "s/{{YOUR_AWS_REGION}}/$AWS_REGION/g" \
| sed "s/{{YOUR_CLUSTER_NAME}}/$ECS_CLUSTER_NAME/g" \
| sed "s/{{YOUR_TASK_DEF_FAMILY}}/$ECS_TASK_DEF_FAMILY/g" \
| xargs -0 aws cloudwatch put-dashboard --dashboard-name ${DASHBOARD_NAME} --region $AWS_REGION --dashboard-body
```
# Amazon ECS Fargate 上の Redis OSS Prometheus メトリクスのスクレイピングに関するチュートリアル
このチュートリアルでは、Amazon ECS Fargate クラスター内のサンプル Redis OSS アプリケーションの Prometheus メトリクスをスクレイピングする方法を実践的に説明します。Redis OSS Prometheus エクスポーターのターゲットは、コンテナの Docker ラベルに基づいて Prometheus メトリクスサポートを持つ CloudWatch エージェントによって自動検出されます。
Redis OSS (https://redis.io/) は、オープンソース (BSD ライセンス適用) のインメモリ型のデータ構造ストアで、データベース、キャッシュ、メッセージブローカーとして使用されます。詳細については、「[redis](https://redis.io/)」を参照してください。
redis\$1exporter (MIT ライセンス適用) は、指定されたポート (デフォルト: 0.0.0.0:9121) で Redis OSS Prometheus メトリクスを公開するために使用します。詳細については、「[redis\$1exporter](https://github.com/oliver006/redis_exporter)」を参照してください。
このチュートリアルでは、次の 2 つの Docker ハブリポジトリの Docker イメージを使用します。
+ [redis](https://hub.docker.com/_/redis?tab=description)
+ [redis\$1exporter](https://hub.docker.com/r/oliver006/redis_exporter)
**前提条件**
Amazon ECS のサンプル Prometheus ワークロードからメトリクスを収集するには、クラスターで Container Insights を実行している必要があります。Container Insights のインストールの詳細については、「[Amazon ECS での Container Insights のセットアップ](deploy-container-insights-ECS.md)」を参照してください。
**Topics**
+ [Amazon ECS Fargate クラスター環境変数を設定する](#ContainerInsights-Prometheus-Setup-redis-ecs-variable)
+ [Amazon ECS Fargate クラスターのネットワーク環境変数を設定する](#ContainerInsights-Prometheus-Setup-redis-ecs-variable2)
+ [サンプル Redis OSS ワークロードのインストール](#ContainerInsights-Prometheus-Setup-redis-ecs-install-workload)
+ [CloudWatch エージェントを設定して Redis OSS Prometheus メトリクスをスクレイピングする](#ContainerInsights-Prometheus-Setup-redis-ecs-agent)
+ [Redis OSS メトリクスの表示](#ContainerInsights-Prometheus-Setup-redis-view)
## Amazon ECS Fargate クラスター環境変数を設定する
**Amazon ECS Fargate クラスター環境変数を設定するには**
1. まだの場合は、Amazon ECS CLI をインストールしてください。詳細については、「[Amazon ECS CLI のインストール](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_CLI_installation.html)」を参照してください。
1. 新しい Amazon ECS クラスター名とリージョンを設定します。例えば、次のようになります。
```
ECS_CLUSTER_NAME=ecs-fargate-redis-tutorial
AWS_DEFAULT_REGION=ca-central-1
```
1. (オプション) サンプル Redis OSS ワークロードと CloudWatch エージェントのインストール先となる Amazon ECS Fargate クラスターがまだない場合は、次のコマンドを入力してクラスターを作成できます。
```
ecs-cli up --capability-iam \
--cluster $ECS_CLUSTER_NAME \
--launch-type FARGATE \
--region $AWS_DEFAULT_REGION
```
このコマンドの予想される結果は次のとおりです。
```
INFO[0000] Created cluster cluster=ecs-fargate-redis-tutorial region=ca-central-1
INFO[0001] Waiting for your cluster resources to be created...
INFO[0001] Cloudformation stack status stackStatus=CREATE_IN_PROGRESS
VPC created: vpc-xxxxxxxxxxxxxxxxx
Subnet created: subnet-xxxxxxxxxxxxxxxxx
Subnet created: subnet-xxxxxxxxxxxxxxxxx
Cluster creation succeeded.
```
## Amazon ECS Fargate クラスターのネットワーク環境変数を設定する
**Amazon ECS Fargate クラスターのネットワーク環境変数を設定するには**
1. Amazon ECS クラスターの VPC とサブネット ID を設定します。前の手順で新しいクラスターを作成した場合は、最後のコマンドの結果にこれらの値が表示されます。それ以外の場合は、Redis で使用する既存のクラスターの ID を使用します。
```
ECS_CLUSTER_VPC=vpc-xxxxxxxxxxxxxxxxx
ECS_CLUSTER_SUBNET_1=subnet-xxxxxxxxxxxxxxxxx
ECS_CLUSTER_SUBNET_2=subnet-xxxxxxxxxxxxxxxxx
```
1. このチュートリアルでは、Redis OSS アプリケーションと CloudWatch エージェントを Amazon ECS クラスターの VPC のデフォルトセキュリティグループにインストールします。デフォルトセキュリティグループでは、同じセキュリティグループ内のすべてのネットワーク接続が許可されるため、CloudWatch エージェントによる Redis OSS コンテナで公開されている Prometheus メトリクスのスクレイピングが可能です。実際の本番環境では、Redis OSS アプリケーションと CloudWatch エージェント専用のセキュリティグループを作成し、カスタマイズしたアクセス許可をそれぞれに設定することもできます。
次のコマンドを入力して、デフォルトのセキュリティグループ ID を取得します。
```
aws ec2 describe-security-groups \
--filters Name=vpc-id,Values=$ECS_CLUSTER_VPC \
--region $AWS_DEFAULT_REGION
```
次に、次のコマンドを入力して、Fargate クラスターデフォルトセキュリティグループ変数を設定します。*my-default-security-group* を前のコマンドから取得した値に置き換えます。
```
ECS_CLUSTER_SECURITY_GROUP=my-default-security-group
```
## サンプル Redis OSS ワークロードのインストール
**Prometheus メトリクスを公開するサンプル Redis OSS ワークロードをインストールするには**
1. 次のコマンドを入力して、Redis OSS CloudFormation テンプレートをダウンロードします。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/sample_traffic/redis/redis-traffic-sample.yaml
```
1. 次のコマンドを入力して、Redis OSS 用に作成する IAM ロール名を設定します。
```
REDIS_ECS_TASK_ROLE_NAME=redis-prometheus-demo-ecs-task-role-name
REDIS_ECS_EXECUTION_ROLE_NAME=redis-prometheus-demo-ecs-execution-role-name
```
1. 次のコマンドを入力して、サンプル Redis OSS ワークロードをインストールします。
```
aws cloudformation create-stack --stack-name Redis-Prometheus-Demo-ECS-$ECS_CLUSTER_NAME-fargate-awsvpc \
--template-body file://redis-traffic-sample.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \
ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET_1 \
ParameterKey=TaskRoleName,ParameterValue=$REDIS_ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$REDIS_ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_DEFAULT_REGION
```
CloudFormation スタックは、次の 4 つのリソースを作成します。
+ 1 つの ECS タスクロール
+ 1 つの ECS タスク実行ロール
+ 1 つの Redis OSS タスク定義
+ 1 つの Redis OSS サービス
Redis OSS タスク定義では、2 つのコンテナが定義されています。
+ プライマリコンテナは単純な Redis OSS アプリケーションを実行し、アクセス用にポート 6379 を開きます。
+ もう一方のコンテナは Redis OSS エクスポータープロセスを実行して、ポート 9121 で Prometheus メトリクスを公開します。これは、CloudWatch エージェントによって検出され、スクレイプされるコンテナです。次のドッカーラベルは、CloudWatch エージェントがそれに基づいてこのコンテナを検出できるように定義されています。
```
ECS_PROMETHEUS_EXPORTER_PORT: 9121
```
## CloudWatch エージェントを設定して Redis OSS Prometheus メトリクスをスクレイピングする
**CloudWatch エージェントを設定して Redis OSS Prometheus メトリクスをスクレイピングするには**
1. 次のコマンドを入力して、`cwagent-ecs-prometheus-metric-for-awsvpc.yaml` の最新バージョンをダウンロードします。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-awsvpc.yaml
```
1. テキストエディタでファイルを開き、`value` セクションの `resource:CWAgentConfigSSMParameter` キーの背後にある完全な CloudWatch エージェント設定を見つけます。
次に、ここに示す `ecs_service_discovery` セクションでは、`docker_label` ベースのサービス検出が、Redis OSS ECS タスク定義で定義した Docker ラベルと一致する `ECS_PROMETHEUS_EXPORTER_PORT` をベースとしたデフォルト設定で有効になっています。したがって、このセクションで変更を加える必要はありません。
```
ecs_service_discovery": {
"sd_frequency": "1m",
"sd_result_file": "/tmp/cwagent_ecs_auto_sd.yaml",
* "docker_label": {
},*
...
```
`metric_declaration` セクションの場合、デフォルト設定で Redis OSS メトリクスは許可されません。Redis OSS メトリクスを許可するには、次のセクションを追加します。デフォルトのインデントパターンに従ってください。
```
{
"source_labels": ["container_name"],
"label_matcher": "^redis-exporter-.*$",
"dimensions": [["ClusterName","TaskDefinitionFamily"]],
"metric_selectors": [
"^redis_net_(in|out)put_bytes_total$",
"^redis_(expired|evicted)_keys_total$",
"^redis_keyspace_(hits|misses)_total$",
"^redis_memory_used_bytes$",
"^redis_connected_clients$"
]
},
{
"source_labels": ["container_name"],
"label_matcher": "^redis-exporter-.*$",
"dimensions": [["ClusterName","TaskDefinitionFamily","cmd"]],
"metric_selectors": [
"^redis_commands_total$"
]
},
{
"source_labels": ["container_name"],
"label_matcher": "^redis-exporter-.*$",
"dimensions": [["ClusterName","TaskDefinitionFamily","db"]],
"metric_selectors": [
"^redis_db_keys$"
]
},
```
1. CloudFormation によって Amazon ECS クラスターに CloudWatch エージェントを既にデプロイしている場合は、次のコマンドを入力して変更セットを作成できます。
```
ECS_LAUNCH_TYPE=FARGATE
CREATE_IAM_ROLES=True
ECS_CLUSTER_SUBNET=$ECS_CLUSTER_SUBNET_1
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-$ECS_CLUSTER_NAME-$ECS_LAUNCH_TYPE-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSLaunchType,ParameterValue=$ECS_LAUNCH_TYPE \
ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \
ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION} \
--change-set-name redis-scraping-support
```
1. [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/) で CloudFormation コンソール を開きます。
1. 新しく作成された変更セット `redis-scraping-support` を確認します。`CWAgentConfigSSMParameter` リソースに 1 つの変更が適用されていることがわかります。次のコマンドを入力して、変更セットを実行し、CloudWatch エージェントタスクを再起動します。
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-$ECS_LAUNCH_TYPE-awsvpc \
--region ${AWS_DEFAULT_REGION}
```
1. 10 秒ほど待ってから、次のコマンドを入力します。
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-$ECS_LAUNCH_TYPE-awsvpc \
--region ${AWS_DEFAULT_REGION}
```
1. クラスターの Prometheus メトリクス収集を使用して CloudWatch エージェントを初めてインストールする場合は、次のコマンドを入力します。
```
ECS_LAUNCH_TYPE=FARGATE
CREATE_IAM_ROLES=True
ECS_CLUSTER_SUBNET=$ECS_CLUSTER_SUBNET_1
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-$ECS_CLUSTER_NAME-$ECS_LAUNCH_TYPE-awsvpc \
--template-body file://cwagent-ecs-prometheus-metric-for-awsvpc.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSLaunchType,ParameterValue=$ECS_LAUNCH_TYPE \
ParameterKey=SecurityGroupID,ParameterValue=$ECS_CLUSTER_SECURITY_GROUP \
ParameterKey=SubnetID,ParameterValue=$ECS_CLUSTER_SUBNET \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region ${AWS_DEFAULT_REGION}
```
## Redis OSS メトリクスの表示
このチュートリアルでは、次のメトリクスを CloudWatch の **ECS/ContainerInsights/Prometheus** 名前空間に送信します。CloudWatch コンソールを使用して、その名前空間のメトリクスを表示できます。
| メトリクス名 | ディメンション |
| --- | --- |
| `redis_net_input_bytes_total` | ClusterName、`TaskDefinitionFamily` |
| `redis_net_output_bytes_total` | ClusterName、`TaskDefinitionFamily` |
| `redis_expired_keys_total` | ClusterName、`TaskDefinitionFamily` |
| `redis_evicted_keys_total` | ClusterName、`TaskDefinitionFamily` |
| `redis_keyspace_hits_total` | ClusterName、`TaskDefinitionFamily` |
| `redis_keyspace_misses_total` | ClusterName、`TaskDefinitionFamily` |
| `redis_memory_used_bytes` | ClusterName、`TaskDefinitionFamily` |
| `redis_connected_clients` | ClusterName、`TaskDefinitionFamily` |
| `redis_commands_total` | ` ClusterName`, `TaskDefinitionFamily`, `cmd` |
| `redis_db_keys` | `ClusterName`, `TaskDefinitionFamily`, `db` |
**注記**
**cmd** ディメンションの値には `append`、`client`、`command`、`config`、`dbsize`、`flushall`、`get`、`incr`、`info`、`latency`、または `slowlog` を指定できます。
**db** ディメンションの値は `db0` から `db15` に指定できます。
また、Redis OSS Prometheus メトリクスの CloudWatch ダッシュボードを作成することもできます。
**Redis OSS Prometheus メトリクスのダッシュボードを作成するには**
1. 環境変数を作成し、以下の値をデプロイに合わせて置き換えます。
```
DASHBOARD_NAME=your_cw_dashboard_name
ECS_TASK_DEF_FAMILY=redis-prometheus-demo-$ECS_CLUSTER_NAME-fargate-awsvpc
```
1. 次のコマンドを入力して、ダッシュボードを作成します。
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/redis/cw_dashboard_redis.json \
| sed "s/{{YOUR_AWS_REGION}}/${REGION_NAME}/g" \
| sed "s/{{YOUR_CLUSTER_NAME}}/${CLUSTER_NAME}/g" \
| sed "s/{{YOUR_NAMESPACE}}/${NAMESPACE}/g" \
```
# Amazon EKS および Kubernetes クラスターでの Prometheus メトリクスコレクションの設定と構成
Amazon EKS または Kubernetes を実行しているクラスターから Prometheus メトリクスを収集するには、CloudWatch エージェントをコレクターとして使用するか、AWS Distro for OpenTelemetry コレクターを使用できます。AWS Distro for OpenTelemetry コレクターの使用については、[https://aws-otel.github.io/docs/getting-started/container-insights/eks-prometheus](https://aws-otel.github.io/docs/getting-started/container-insights/eks-prometheus) を参照してください。
以下のセクションでは、CloudWatch エージェントを使用して Prometheus メトリクスを収集する方法について説明します。Amazon EKS または Kubernetes を実行しているクラスターに Prometheus モニターリングを使用して CloudWatch エージェントをインストールする方法と、追加のターゲットをスクレイプするようにエージェントを設定する方法について説明します。また、Prometheus モニターリングでのテストに使用するサンプルワークロードを設定するためのオプションのチュートリアルも提供します。
**Topics**
+ [Amazon EKS および Kubernetes クラスターに Prometheus メトリクスコレクションを使用して CloudWatch エージェントをインストールする](ContainerInsights-Prometheus-Setup.md)
# Amazon EKS および Kubernetes クラスターに Prometheus メトリクスコレクションを使用して CloudWatch エージェントをインストールする
このセクションでは、Amazon EKS または Kubernetes を実行しているクラスターで Prometheus モニターリングを使用して CloudWatch エージェントをセットアップする方法について説明します。これを行うと、エージェントは、そのクラスターで実行されている次のワークロードのメトリクスを自動的にスクレイプし、インポートします。
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
+ Fluent Bit
また、追加の Prometheus ワークロードとソースをスクレイプしてインポートするようにエージェントを設定することもできます。
以下のステップに従って Prometheus メトリクスコレクション用の CloudWatch エージェントをインストールする前に、Amazon EKS でクラスターが実行されているか、Amazon EC2 インスタンスで Kubernetes クラスターが実行されている必要があります。
**VPC セキュリティグループの要件**
Prometheus ワークロードのセキュリティグループの受信ルールでは、Prometheus のメトリクスをプライベート IP でスクレイピングするために、CloudWatch エージェントへの Prometheus ポートを開く必要があります。
CloudWatch エージェントのセキュリティグループの出力ルールでは、CloudWatch エージェントがプライベート IP によって Prometheus ワークロードのポートに接続できるようにする必要があります。
**Topics**
+ [Amazon EKS および Kubernetes クラスターに Prometheus メトリクスコレクションを使用して CloudWatch エージェントをインストールする](#ContainerInsights-Prometheus-Setup-roles)
+ [追加の Prometheus ソースのスクレイピングと、それらのメトリクスのインポート](ContainerInsights-Prometheus-Setup-configure.md)
+ [(オプション) Prometheus メトリクスのテストのためにコンテナ化された Amazon EKS サンプルワークロードを設定する](ContainerInsights-Prometheus-Sample-Workloads.md)
## Amazon EKS および Kubernetes クラスターに Prometheus メトリクスコレクションを使用して CloudWatch エージェントをインストールする
このセクションでは、Amazon EKS または Kubernetes を実行しているクラスターで Prometheus モニターリングを使用して CloudWatch エージェントをセットアップする方法について説明します。これを行うと、エージェントは、そのクラスターで実行されている次のワークロードのメトリクスを自動的にスクレイプし、インポートします。
+ AWS App Mesh
+ NGINX
+ Memcached
+ Java/JMX
+ HAProxy
+ Fluent Bit
また、追加の Prometheus ワークロードとソースをスクレイプしてインポートするようにエージェントを設定することもできます。
以下のステップに従って Prometheus メトリクスコレクション用の CloudWatch エージェントをインストールする前に、Amazon EKS でクラスターが実行されているか、Amazon EC2 インスタンスで Kubernetes クラスターが実行されている必要があります。
**VPC セキュリティグループの要件**
Prometheus ワークロードのセキュリティグループの受信ルールでは、Prometheus のメトリクスをプライベート IP でスクレイピングするために、CloudWatch エージェントへの Prometheus ポートを開く必要があります。
CloudWatch エージェントのセキュリティグループの出力ルールでは、CloudWatch エージェントがプライベート IP によって Prometheus ワークロードのポートに接続できるようにする必要があります。
**Topics**
+ [IAM ロールの設定](#ContainerInsights-Prometheus-Setup-roles)
+ [Prometheus メトリクスを収集するための CloudWatch エージェントのインストール](#ContainerInsights-Prometheus-Setup-install-agent)
### IAM ロールの設定
最初のステップでは、クラスターで必要な IAM ロールを設定します。2 つの方法があります。
+ サービスアカウントの IAM ロール (*サービスロール*とも呼ばれます) を設定します。このメソッドは、EC2 起動タイプと Fargate 起動タイプの両方で機能します。
+ クラスターに使用される IAM ロールに IAM ポリシーを追加します。これは EC2 起動タイプでのみ機能します。
**サービスロール (EC2 起動タイプと Fargate 起動タイプ) を設定する**
サービスロールを設定するには、次のコマンドを入力します。*MyCluster* をクラスターの名前に置き換えます。
```
eksctl create iamserviceaccount \
--name cwagent-prometheus \
--namespace amazon-cloudwatch \
--cluster MyCluster \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchAgentServerPolicy \
--approve \
--override-existing-serviceaccounts
```
**ノードグループの IAM ロールにポリシーを追加する (EC2 起動タイプのみ)**
**Prometheus のサポートのためにノードグループで IAM ポリシーを設定するには**
1. Amazon EC2 コンソールの [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) を開いてください。
1. ナビゲーションペインで、[**インスタンス**] を選択してください。
1. クラスターの IAM ロール名のプレフィックスを検索する必要があります。これを行うには、クラスター内のインスタンスの名前の横にあるチェックボックスをオンにし、[**アクション**]、[**セキュリティ**]、[**IAM Role を変更**] の順に選択します。次に、IAM ロールのプレフィックス (`eksctl-dev303-workshop-nodegroup` など) をコピーします。
1. IAM コンソール ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)) を開きます。
1. ナビゲーションペインで **Roles (ロール) ** を選択してください。
1. 検索ボックスを使用して、この手順で先ほどコピーしたプレフィックスを検索し、そのロールを選択します。
1. [**ポリシーのアタッチ**] を選択します。
1. 検索ボックスを使用して、[**CloudWatchAgentServerPolicy**] を検索します。[**CloudWatchAgentServerPolicy**] の横にあるチェックボックスをオンにして、[**Attach policy (ポリシーをアタッチ)**] を選択します。
### Prometheus メトリクスを収集するための CloudWatch エージェントのインストール
メトリクスを収集するには、CloudWatch エージェントをクラスターにインストールする必要があります。エージェントのインストール方法は、Amazon EKS クラスターと Kubernetes クラスターによって異なります。
**Prometheus をサポートする以前のバージョンの CloudWatch エージェントを削除する**
Prometheus をサポートするバージョンの CloudWatch エージェントが既にクラスターにインストールされている場合は、次のコマンドを入力してそのバージョンを削除する必要があります。この操作は、Prometheus をサポートする以前のバージョンのエージェントでのみ必要です。Prometheus をサポートせずに Container Insights を有効にする CloudWatch エージェントを削除する必要はありません。
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
#### EC2 起動タイプの Amazon EKS クラスターへの CloudWatch エージェントのインストール
Prometheus をサポートする CloudWatch エージェントを Amazon EKS クラスターにインストールするには、次の手順に従います。
**Amazon EKS クラスターに Prometheus サポートをする CloudWatch エージェントをインストールするには**
1. 次のコマンドを入力して、`amazon-cloudwatch` 名前空間がすでに作成されているかどうかを確認します。
```
kubectl get namespace
```
1. 結果に `amazon-cloudwatch` が表示されない場合は、次のコマンドを入力して作成します。
```
kubectl create namespace amazon-cloudwatch
```
1. デフォルトの設定でエージェントをデプロイし、インストール先の AWS リージョンにデータを送信するには、次のコマンドを入力します。
```
kubectl apply -f https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
エージェントから代わりに別のリージョンにデータを送信するには、次のステップに従います。
1. 次のコマンドを入力して、エージェントの YAML ファイルをダウンロードします。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
1. テキストエディタでファイルを開き、ファイルの `cwagentconfig.json` ブロックを検索します。
1. ハイライト表示された行を追加し、必要なリージョンを指定します。
```
cwagentconfig.json: |
{
"agent": {
"region": "us-east-2"
},
"logs": { ...
```
1. ファイルを保存し、更新されたファイルを使用してエージェントをデプロイします。
```
kubectl apply -f prometheus-eks.yaml
```
#### Fargate 起動タイプの Amazon EKS クラスターへの CloudWatch エージェントのインストール
Prometheus をサポートする CloudWatch エージェントを Fargate 起動タイプの Amazon EKS クラスターにインストールするには、次の手順に従います。
**Prometheus をサポートする CloudWatch エージェントを Fargate 起動タイプの Amazon EKS クラスターにインストールするには**
1. クラスター内で実行できるように、次のコマンドを入力して、CloudWatch エージェントの Fargate プロファイルを作成します。*MyCluster* をクラスターの名前に置き換えます。
```
eksctl create fargateprofile --cluster MyCluster \
--name amazon-cloudwatch \
--namespace amazon-cloudwatch
```
1. CloudWatch エージェントをインストールするには、次のコマンドを入力します。*MyCluster* をクラスターの名前に置き換えます。この名前は、エージェントによって収集されたログイベントを保存するロググループ名に使用されます。また、エージェントによって収集されたメトリクスのディメンションとしても使用されます。
*region* は、メトリクスの送信先となるリージョンの名前に置き換えます。例えば、`us-west-1`。
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml |
sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" |
kubectl apply -f -
```
#### Kubernetes クラスターへの CloudWatch エージェントのインストール
Kubernetes を実行しているクラスターに Prometheus をサポートする CloudWatch エージェントをインストールするには、次のコマンドを入力します。
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml |
sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" |
kubectl apply -f -
```
*MyCluster* をクラスターの名前に置き換えます。この名前は、エージェントによって収集されたログイベントを保存するロググループ名に使用されます。また、エージェントによって収集されたメトリクスのディメンションとしても使用されます。
*region* は、メトリクスの送信先となる AWS リージョンの名前に置き換えます。例えば、**us-west-1**。
#### エージェントが実行されていることを確認する
Amazon EKS と Kubernetes クラスターの両方で、次のコマンドを入力して、エージェントが実行中であることを確認できます。
```
kubectl get pod -l "app=cwagent-prometheus" -n amazon-cloudwatch
```
結果に `Running` 状態の 1 つの CloudWatch エージェントポッドが含まれる場合、エージェントは実行中であり、Prometheus メトリクスを収集しています。デフォルトでは、CloudWatch エージェントは、App Mesh、NGINX、Memcached、Java/JMX、および HAProxy のメトリクスを毎分収集します。これらのメトリクスの詳細については、「[CloudWatch エージェントにより収集される Prometheus メトリクス](ContainerInsights-Prometheus-metrics.md)」を参照してください。CloudWatch で Prometheus メトリクスを表示する方法については「[Prometheus メトリクスの表示](ContainerInsights-Prometheus-viewmetrics.md)」を参照してください。
他の Prometheus エクスポーターからメトリクスを収集するよう CloudWatch エージェントを設定することもできます。詳細については、「[追加の Prometheus ソースのスクレイピングと、それらのメトリクスのインポート](ContainerInsights-Prometheus-Setup-configure.md)」を参照してください。
# 追加の Prometheus ソースのスクレイピングと、それらのメトリクスのインポート
Prometheus モニターリングを使用した CloudWatch エージェントは、Prometheus メトリクスをスクレイプするために 2 つの設定が必要です。1 つは標準の Prometheus 設定用で、Prometheus ドキュメントの「[](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config)」に記載されています。もう 1 つは CloudWatch エージェント設定用です。
Amazon EKS クラスターの場合、設定は `prometheus-eks.yaml` (EC2 起動タイプの場合) または `prometheus-eks-fargate.yaml` (Fargate 起動タイプの場合) で 2 つの設定マップとして定義されます。
+ `name: prometheus-config` セクションには、Prometheus のスクレイピング設定が含まれています。
+ `name: prometheus-cwagentconfig` セクションには、CloudWatch エージェントの設定が含まれています。このセクションを使用して、CloudWatch で Prometheus メトリクスを収集する方法を設定できます。例えば、どのメトリクスを CloudWatch にインポートするかを指定し、ディメンションを定義します。
Amazon EC2 インスタンスで実行されている Kubernetes クラスターの場合、設定は `prometheus-k8s.yaml` YAML ファイルで 2 つの設定マップとして定義されます。
+ `name: prometheus-config` セクションには、Prometheus のスクレイピング設定が含まれています。
+ `name: prometheus-cwagentconfig` セクションには、CloudWatch エージェントの設定が含まれています。
追加の Prometheus メトリクスソースをスクレイプし、それらのメトリクスを CloudWatch にインポートするには、Prometheus スクレイプ設定と CloudWatch エージェント設定の両方を変更し、更新された設定でエージェントを再デプロイします。
**VPC セキュリティグループの要件**
Prometheus ワークロードのセキュリティグループの受信ルールでは、Prometheus のメトリクスをプライベート IP でスクレイピングするために、CloudWatch エージェントへの Prometheus ポートを開く必要があります。
CloudWatch エージェントのセキュリティグループの出力ルールでは、CloudWatch エージェントがプライベート IP によって Prometheus ワークロードのポートに接続できるようにする必要があります。
## Prometheus スクレイプ設定
この CloudWatch エージェントは、Prometheus のドキュメントの「[](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config)」に記載されているように、標準の Prometheus スクレイプ設定をサポートしています。このセクションを編集して、このファイルに既に含まれている設定を更新したり、Prometheus スクレイピングターゲットを追加したりできます。デフォルトでは、サンプル設定ファイルに次のグローバル設定行が含まれています。
```
global:
scrape_interval: 1m
scrape_timeout: 10s
```
+ **scrape\$1interval** – ターゲットをスクレイプする頻度を定義します。
+ **scrape\$1timeout** – スクレイプリクエストがタイムアウトするまでの待機時間を定義します。
また、ジョブレベルでこれらの設定に対して異なる値を定義し、グローバル設定をオーバーライドすることもできます。
### Prometheus スクレイピングジョブ
CloudWatch エージェント YAML ファイルには、既にいくつかのデフォルトのスクレイピングジョブが設定されています。例えば、`prometheus-eks.yaml` では、デフォルトのスクレイピングジョブは、`job_name` セクションの `scrape_configs` 行で設定されています。このファイルで、次のデフォルト `kubernetes-pod-jmx` セクションは、JMX Exporter メトリクスをスクレイピングします。
```
- job_name: 'kubernetes-pod-jmx'
sample_limit: 10000
metrics_path: /metrics
kubernetes_sd_configs:
- role: pod
relabel_configs:
- source_labels: [__address__]
action: keep
regex: '.*:9404$'
- action: labelmap
regex: __meta_kubernetes_pod_label_(.+)
- action: replace
source_labels:
- __meta_kubernetes_namespace
target_label: Namespace
- source_labels: [__meta_kubernetes_pod_name]
action: replace
target_label: pod_name
- action: replace
source_labels:
- __meta_kubernetes_pod_container_name
target_label: container_name
- action: replace
source_labels:
- __meta_kubernetes_pod_controller_name
target_label: pod_controller_name
- action: replace
source_labels:
- __meta_kubernetes_pod_controller_kind
target_label: pod_controller_kind
- action: replace
source_labels:
- __meta_kubernetes_pod_phase
target_label: pod_phase
```
これらのデフォルトターゲットはそれぞれスクレイピングされ、メトリクスは埋め込みメトリクス形式を使用してログイベントで CloudWatch に送信されます。詳細については、「[ログ内へのメトリクスの埋め込み](CloudWatch_Embedded_Metric_Format.md)」を参照してください。
Amazon EKS および Kubernetes クラスターからのログイベントは、CloudWatch Logs の [**/aws/containerinsights/*cluster\$1name*/prometheus**] ロググループに保存されます。Amazon ECS クラスターからのログイベントは、[**/aws/ecs/containerinsights/*cluster\$1name*/prometheus**] ロググループに保存されます。
各スクレイピングジョブは、このロググループ内の異なるログストリームに含まれています。例えば、Prometheus スクレイピングジョブ `kubernetes-pod-appmesh-envoy` が App Mesh に対して定義されています。Amazon EKS および Kubernetes クラスターのすべての App Mesh Prometheus メトリクスは、[**/aws/containerinsights/*cluster\$1name*>prometheus/kubernetes-pod-appmesh-envoy/**] という名前のログストリームに送信されます。
新しいスクレイピングターゲットを追加するには、YAML ファイルの `job_name` セクションに新しい `scrape_configs` セクションを追加し、エージェントを再起動します。このプロセスの例については、「[新しい Prometheus スクレイピングターゲットを追加するためのチュートリアル: Prometheus API サーバーメトリクス](#ContainerInsights-Prometheus-Setup-new-exporters)」を参照してください。
## Prometheus の CloudWatch エージェント設定
CloudWatch エージェント設定ファイルには、Prometheus スクレイピング設定の `prometheus` の `metrics_collected` セクションがあります。これには、次の設定オプションが含まれます。
+ **cluster\$1name** – ログイベントのラベルとして追加されるクラスター名を指定します。このフィールドはオプションです。これを省略すると、エージェントは Amazon EKS または Kubernetes クラスター名を検出できます。
+ **log\$1group\$1name** – スクレイプされた Prometheus メトリクスのロググループ名を指定します。このフィールドはオプションです。これを省略すると、CloudWatch では Amazon EKS および Kubernetes クラスターからのログに **/aws/containerinsights/*cluster\$1name*/prometheus** が使用されます。
+ **prometheus\$1config\$1path** – Prometheus スクレイプ設定ファイルパスを指定します。このフィールドの値が `env:` で始まる場合、Prometheus スクレイプ設定ファイルの内容は、コンテナの環境変数から取得されます。このフィールドは変更しないでください。
+ **ecs\$1service\$1discovery** – Amazon ECS Prometheus サービス検出の設定を指定するセクションです。詳細については、「[Amazon ECS クラスターでの自動検出の詳細ガイド](ContainerInsights-Prometheus-Setup-autodiscovery-ecs.md)」を参照してください。
`ecs_service_discovery` セクションには、次のフィールドを含めることができます。
+ `sd_frequency` は、Prometheus エクスポーターを検出する頻度です。数値と単位サフィックスを指定します。例えば、`1m` の場合は 1 分に 1 回、`30s` の場合は 30 秒に 1 回です。有効な単位サフィックスは、`ns`、`us`、`ms`、`s`、`m`、`h` です。
このフィールドはオプションです。デフォルト値は 60 秒 (1 分) です。
+ `sd_target_cluster` は、自動検出のターゲット Amazon ECS クラスター名です。このフィールドはオプションです。デフォルトは、CloudWatch エージェントがインストールされている Amazon ECS クラスターの名前です。
+ `sd_cluster_region` は、ターゲット Amazon ECS クラスターのリージョンです。このフィールドはオプションです。デフォルトは、CloudWatch エージェントがインストールされている Amazon ECS クラスターのリージョンです。
+ `sd_result_file` は、Prometheus ターゲット結果の YAML ファイルのパスです。Prometheus スクレイプ設定は、このファイルを参照します。
+ `docker_label` は、docker のラベルベースのサービス検出の設定を指定するために使用できるオプションのセクションです。このセクションを省略すると、docker のラベルベースの検出は使用されません。このセクションには、次のフィールドを含めることができます。
+ `sd_port_label` は、Prometheus メトリクスのコンテナポートを指定するコンテナの docker ラベル名です。デフォルト値は `ECS_PROMETHEUS_EXPORTER_PORT` です。コンテナにこの docker ラベルがない場合、CloudWatch エージェントはそれをスキップします。
+ `sd_metrics_path_label` は、Prometheus メトリクスパスを指定するコンテナの docker ラベル名です。デフォルト値は `ECS_PROMETHEUS_METRICS_PATH` です。コンテナにこの docker ラベルがない場合は、エージェントはデフォルトパス `/metrics` を想定します。
+ `sd_job_name_label` は、Prometheus スクレイプジョブ名を指定するコンテナの docker ラベル名です。デフォルト値は `job` です。コンテナにこの docker ラベルがない場合、CloudWatch エージェントは Prometheus スクレイプ設定でジョブ名を使用します。
+ `task_definition_list` は、タスク定義ベースのサービス検出の設定を指定するために使用できるオプションのセクションです。このセクションを省略すると、タスク定義ベースの検出は使用されません。このセクションには、次のフィールドを含めることができます。
+ `sd_task_definition_arn_pattern` は、検出する Amazon ECS タスク定義を指定するために使用するパターンです。これは正規表現です。
+ `sd_metrics_ports` に、Prometheus メトリクスの containerPort を示します。containerPort はセミコロンで区切ります。
+ `sd_container_name_pattern` は、Amazon ECS タスクコンテナ名を指定します。これは正規表現です。
+ `sd_metrics_path` は、Prometheus のメトリクスパスを指定します。これを省略すると、エージェントはデフォルトのパス `/metrics` を引き受けます。
+ `sd_job_name` Prometheus スクレイプジョブ名を指定します。このフィールドを省略すると、CloudWatch エージェントは Prometheus スクレイプ設定のジョブ名を使用します。
+ **metric\$1declaration** – 生成されるメトリクス形式が埋め込まれたログの配列を指定するセクションです。CloudWatch エージェントがインポートする各 Prometheus ソースには、デフォルトで `metric_declaration` セクションがあります。これらの各セクションには、次のフィールドが含まれています。
+ `label_matcher` は、 `source_labels` に表示されているラベルの値をチェックする正規表現です。一致するメトリクスは、CloudWatch に送信される埋め込みメトリクス形式に含めることができます。
`source_labels` で複数のラベルを指定する場合は、`^` の正規表現に `$` や `label_matcher` 文字を使用しないことをお勧めします。
+ `source_labels` は、`label_matcher` 行によってチェックされるラベルの値を指定します。
+ `label_separator` は、複数の ` label_matcher` が指定されている場合に、`source_labels` 行で使用するセパレータを指定します。デフォルト: `;`。このデフォルトは、次の例の `label_matcher` 行で使用されています。
+ `metric_selectors` は、収集され、CloudWatch に送信されるメトリクスを指定する正規表現です。
+ `dimensions` は、選択した各メトリクスの CloudWatch ディメンションとして使用されるラベルのリストです。
次の `metric_declaration` の例を参照してください。
```
"metric_declaration": [
{
"source_labels":[ "Service", "Namespace"],
"label_matcher":"(.*node-exporter.*|.*kube-dns.*);kube-system",
"dimensions":[
["Service", "Namespace"]
],
"metric_selectors":[
"^coredns_dns_request_type_count_total$"
]
}
]
```
この例では、次の条件が満たされた場合にログイベントとして送信される埋め込みメトリクス形式セクションを設定します。
+ `Service` の値には `node-exporter` または `kube-dns` が含まれます。
+ `Namespace` の値は `kube-system` です。
+ Prometheus メトリクス `coredns_dns_request_type_count_total` には、`Service` ラベルおよび `Namespace` ラベルの両方が含まれます。
送信されるログイベントには、次の強調表示されたセクションが含まれます。
```
{
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"coredns_dns_request_type_count_total"
}
],
"Dimensions":[
[
"Namespace",
"Service"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
"Namespace":"kube-system",
"Service":"kube-dns",
"coredns_dns_request_type_count_total":2562,
"eks_amazonaws_com_component":"kube-dns",
"instance":"192.168.61.254:9153",
"job":"kubernetes-service-endpoints",
...
}
```
## 新しい Prometheus スクレイピングターゲットを追加するためのチュートリアル: Prometheus API サーバーメトリクス
Kubernetes API サーバーは、デフォルトでエンドポイントで Prometheus メトリクスを公開します。Kubernetes API サーバーのスクレイピング設定に関する公式のサンプルは、[GitHub](https://github.com/prometheus/prometheus/blob/main/documentation/examples/prometheus-kubernetes.yml) で入手できます。
次のチュートリアルでは、次のステップを実行して Kubernetes API サーバーメトリクスを CloudWatch にインポートする方法を示します。
+ CloudWatch エージェントの YAML ファイルに、Kubernetes API サーバーの Prometheus スクレイピング設定を追加します。
+ CloudWatch エージェントの YAML ファイルに埋め込まれたメトリクス形式のメトリクス定義を設定します。
+ (オプション) Kubernetes API サーバーメトリクスの CloudWatch ダッシュボードを作成します。
**注記**
Kubernetes API サーバーは、ゲージ、カウンター、ヒストグラム、およびサマリーメトリクスを公開します。このリリースの Prometheus メトリクスサポートでは、CloudWatch はゲージ、カウンター、およびサマリータイプのメトリクスのみをインポートします。
**CloudWatch で Kubernetes API サーバー Prometheus メトリクスの収集を開始するには**
1. 次のコマンドのいずれかを入力して、最新バージョンの `prometheus-eks.yaml`、`prometheus-eks-fargate.yaml`、または `prometheus-k8s.yaml` ファイルをダウンロードします。
EC2 起動タイプの Amazon EKS クラスターの場合は、次のコマンドを入力します。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
Fargate 起動タイプの Amazon EKS クラスターの場合は、次のコマンドを入力します。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml
```
Amazon EC2 インスタンスで実行されている Kubernetes クラスターの場合は、次のコマンドを入力します。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml
```
1. テキストエディタでファイルを開き、`prometheus-config` セクションを見つけ、そのセクション内に次のセクションを追加します。次に、変更を保存します。
```
# Scrape config for API servers
- job_name: 'kubernetes-apiservers'
kubernetes_sd_configs:
- role: endpoints
namespaces:
names:
- default
scheme: https
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
relabel_configs:
- source_labels: [__meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
action: keep
regex: kubernetes;https
- action: replace
source_labels:
- __meta_kubernetes_namespace
target_label: Namespace
- action: replace
source_labels:
- __meta_kubernetes_service_name
target_label: Service
```
1. テキストエディタで YAML ファイルを開いている間に、`cwagentconfig.json` セクションを見つけます。次のサブセクションを追加し、変更を保存します。このセクションでは、API サーバーメトリクスを CloudWatch エージェント許可リストに追加します。次の 3 種類の API サーバーメトリクスを許可リストに追加します。
+ etcd オブジェクト数
+ API サーバー登録コントローラーメトリクス
+ API サーバー要求メトリクス
```
{"source_labels": ["job", "resource"],
"label_matcher": "^kubernetes-apiservers;(services|daemonsets.apps|deployments.apps|configmaps|endpoints|secrets|serviceaccounts|replicasets.apps)",
"dimensions": [["ClusterName","Service","resource"]],
"metric_selectors": [
"^etcd_object_counts$"
]
},
{"source_labels": ["job", "name"],
"label_matcher": "^kubernetes-apiservers;APIServiceRegistrationController$",
"dimensions": [["ClusterName","Service","name"]],
"metric_selectors": [
"^workqueue_depth$",
"^workqueue_adds_total$",
"^workqueue_retries_total$"
]
},
{"source_labels": ["job","code"],
"label_matcher": "^kubernetes-apiservers;2[0-9]{2}$",
"dimensions": [["ClusterName","Service","code"]],
"metric_selectors": [
"^apiserver_request_total$"
]
},
{"source_labels": ["job"],
"label_matcher": "^kubernetes-apiservers",
"dimensions": [["ClusterName","Service"]],
"metric_selectors": [
"^apiserver_request_total$"
]
},
```
1. Prometheus をサポートする CloudWatch エージェントが既にクラスタにデプロイされている場合は、次のコマンドを入力してエージェントを削除する必要があります。
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
1. 次のいずれかのコマンドを入力して、更新した設定で CloudWatch エージェントをデプロイします。EC2 起動タイプの Amazon EKS クラスターの場合は、次を入力します:
```
kubectl apply -f prometheus-eks.yaml
```
Fargate 起動タイプの Amazon EKS クラスターの場合は、次のコマンドを入力します。*MyCluster* および *region* を、デプロイに合った値に置き換えます。
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Kubernetes クラスターの場合は、次のコマンドを入力します。*MyCluster* および *region* を、デプロイに合った値に置き換えます。
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
これを行うと、[**/aws/containerinsights/*cluster\$1name*/prometheus**] ロググループに [**kubernetes-apiservers**] という名前の新しいログストリームが表示されます。このログストリームには、次のような埋め込みメトリクス形式の定義を持つログイベントを含める必要があります。
```
{
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"apiserver_request_total"
}
],
"Dimensions":[
[
"ClusterName",
"Service"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
"ClusterName":"my-cluster-name",
"Namespace":"default",
"Service":"kubernetes",
"Timestamp":"1592267020339",
"Version":"0",
"apiserver_request_count":0,
"apiserver_request_total":0,
"code":"0",
"component":"apiserver",
"contentType":"application/json",
"instance":"192.0.2.0:443",
"job":"kubernetes-apiservers",
"prom_metric_type":"counter",
"resource":"pods",
"scope":"namespace",
"verb":"WATCH",
"version":"v1"
}
```
CloudWatch コンソールで [**ContainerInsights/Prometheus**] 名前空間のメトリクスを表示できます。オプションで、Prometheus Kubernetes API サーバーメトリクスの CloudWatch ダッシュボードを作成することもできます。
### (オプション) Kubernetes API サーバーメトリクスのダッシュボードの作成
ダッシュボードに Kubernetes API サーバーメトリクスを表示するには、前のセクションのステップをまず完了して、CloudWatch でこれらのメトリクスの収集を開始する必要があります。
**Kubernetes API サーバーメトリクスのダッシュボードを作成するには**
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. 正しい AWS リージョンが選択されていることを確認します。
1. ナビゲーションペインで、**ダッシュボード**を選択します。
1. [**ダッシュボードの作成**] を選択します。新しいダッシュボードの名前を入力し、[**ダッシュボードの作成**] を選択します。
1. [**このダッシュボードに追加**] で、[**キャンセル**] を選択します。
1. [**アクション**]、[**ソースの表示/編集**] を選択します。
1. JSON ファイル [Kubernetes API ダッシュボードソース](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/kubernetes_api_server/cw_dashboard_kubernetes_api_server.json)をダウンロードします。
1. ダウンロードした JSON ファイルをテキストエディタで開き、次の変更を加えます。
+ すべての `{{YOUR_CLUSTER_NAME}}` 文字列をクラスターの正確な名前に置き換えます。テキストの前後に空白を追加しないようにしてください。
+ すべての `{{YOUR_AWS_REGION}}` 文字列を、メトリクスを収集するリージョンの名前に置き換えます。例: `us-west-2`。テキストの前後に空白を追加しないようにしてください。
1. JSON BLOB 全体をコピーし、CloudWatch コンソールのテキストボックスに貼り付けて、ボックスに既に入力されている内容を置き換えます。
1. [**更新**]、[**ダッシュボードの保存**] の順に選択します。
# (オプション) Prometheus メトリクスのテストのためにコンテナ化された Amazon EKS サンプルワークロードを設定する
CloudWatch Container Insights で Prometheus メトリクスのサポートをテストするには、次のコンテナ化されたワークロードを 1 つ以上設定できます。Prometheus をサポートする CloudWatch エージェントは、これらの各ワークロードからメトリクスを自動的に収集します。デフォルトで収集されるメトリクスを表示する方法については、「[CloudWatch エージェントにより収集される Prometheus メトリクス](ContainerInsights-Prometheus-metrics.md)」を参照してください。
これらのワークロードをインストールする前に、次のコマンドを入力して Helm 3.x をインストールする必要があります。
```
brew install helm
```
詳細については、「[Helm](https://helm.sh)」を参照してください。
**Topics**
+ [Amazon EKS および Kubernetes の AWS App Mesh サンプルワークロードを設定する](ContainerInsights-Prometheus-Sample-Workloads-appmesh.md)
+ [サンプルトラフィックを使用して、Amazon EKS および Kubernetes で NGINX をセットアップする](ContainerInsights-Prometheus-Sample-Workloads-nginx.md)
+ [メトリクスエクスポーターを使用して、Amazon EKS および Kubernetes で memcached をセットアップする](ContainerInsights-Prometheus-Sample-Workloads-memcached.md)
+ [Amazon EKS および Kubernetes で Java/JMX サンプルワークロードをセットアップする](ContainerInsights-Prometheus-Sample-Workloads-javajmx.md)
+ [メトリクスエクスポーターを使用して、Amazon EKS および Kubernetes で HAProxy をセットアップする](ContainerInsights-Prometheus-Sample-Workloads-haproxy.md)
+ [Prometheus スクレイピングの新しいターゲットの追加に関するチュートリアル: Amazon EKS クラスターと Kubernetes クラスター上の Redis OSS](ContainerInsights-Prometheus-Setup-redis-eks.md)
# Amazon EKS および Kubernetes の AWS App Mesh サンプルワークロードを設定する
CloudWatch Container Insights での Prometheus サポートでは、 がサポートされていますAWS App Mesh 次のセクションでは、App Mesh の設定方法について説明します。
**Topics**
+ [EC2 起動タイプの Amazon EKS クラスターまたは Kubernetes クラスターで AWS App Mesh サンプルワークロードを設定する](ContainerInsights-Prometheus-Sample-Workloads-appmesh-EKS.md)
+ [Fargate 起動タイプの Amazon EKS クラスターで AWS App Mesh サンプルワークロードを設定する](ContainerInsights-Prometheus-Sample-Workloads-appmesh-Fargate.md)
# EC2 起動タイプの Amazon EKS クラスターまたは Kubernetes クラスターで AWS App Mesh サンプルワークロードを設定する
EC2 起動タイプの Amazon EKS を実行しているクラスターまたは Kubernetes クラスターで App Mesh を設定する場合は、以下の手順を使用します。
## IAM 許可を設定する
Amazon EKS または Kubernetes ノードグループの IAM ロールに **AWSAppMeshFullAccess** ポリシーを追加する必要があります。Amazon EKS の場合、このノードグループ名は `eksctl-integ-test-eks-prometheus-NodeInstanceRole-ABCDEFHIJKL` のようになります。Kubernetes の場合は、`nodes.integ-test-kops-prometheus.k8s.local` のようになることもあります。
## App Mesh のインストール
App Mesh Kubernetes コントローラーをインストールするには、「[App Mesh コントローラー](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller)」の手順に従います。
## サンプルアプリケーションをインストールする
「[aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples)」には、複数の Kubernetes App Mesh チュートリアルが含まれています。このチュートリアルでは、http ルートがヘッダーを使用して着信リクエストを照合する方法を示すサンプルカラーアプリケーションをインストールします。
**App Mesh サンプルアプリケーションを使用して Container Insights をテストするには**
1. 「[https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-http-headers](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-http-headers)」の手順に従ってアプリケーションをインストールします。
1. curler ポッドを起動してトラフィックを生成します。
```
kubectl -n default run -it curler --image=tutum/curl /bin/bash
```
1. HTTP ヘッダーを変更し、異なるエンドポイントに対して curl を使用します。次のように curl コマンドを複数回実行します。
```
curl -H "color_header: blue" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo;
curl -H "color_header: red" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo;
curl -H "color_header: yellow" front.howto-k8s-http-headers.svc.cluster.local:8080/; echo;
```
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. クラスターが実行されている AWS リージョンで、ナビゲーションペインから [**Metrics**] (メトリクス) を選択します。このメトリクスは、[**ContainerInsights/Prometheus**] 名前空間にあります。
1. CloudWatch Logs イベントを表示するには、ナビゲーションペインで [**Log Groups (ロググループ)**] を選択します。イベントは、ログストリーム ` /aws/containerinsights/your_cluster_name/prometheus ` のロググループ `kubernetes-pod-appmesh-envoy` にあります 。
## App Mesh テスト環境の削除
App Mesh とサンプルアプリケーションの使用が終了したら、次のコマンドを使用して不要なリソースを削除します。サンプルアプリケーションを削除するには、次のコマンドを入力します。
```
cd aws-app-mesh-examples/walkthroughs/howto-k8s-http-headers/
kubectl delete -f _output/manifest.yaml
```
App Mesh コントローラーを削除するには、次のコマンドを入力します。
```
helm delete appmesh-controller -n appmesh-system
```
# Fargate 起動タイプの Amazon EKS クラスターで AWS App Mesh サンプルワークロードを設定する
Fargate 起動タイプの Amazon EKS を実行しているクラスターで App Mesh を設定する場合は、以下の手順を使用します。
## IAM 許可を設定する
IAM アクセス許可を設定するには、次のコマンドを入力します。*MyCluster* をクラスターの名前に置き換えます。
```
eksctl create iamserviceaccount --cluster MyCluster \
--namespace howto-k8s-fargate \
--name appmesh-pod \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshEnvoyAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapDiscoverInstanceAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess \
--override-existing-serviceaccounts \
--approve
```
## App Mesh のインストール
App Mesh Kubernetes コントローラーをインストールするには、「[App Mesh コントローラー](https://github.com/aws/eks-charts/tree/master/stable/appmesh-controller#app-mesh-controller)」の手順に従います。Fargate 起動タイプの Amazon EKS の指示に従ってください。
## サンプルアプリケーションをインストールする
「[aws-app-mesh-examples](https://github.com/aws/aws-app-mesh-examples)」には、複数の Kubernetes App Mesh チュートリアルが含まれています。このチュートリアルでは、Fargate 起動タイプの Amazon EKS クラスターで動作するサンプルカラーアプリケーションをインストールします。
**App Mesh サンプルアプリケーションを使用して Container Insights をテストするには**
1. 「[https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-fargate](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-fargate)」の手順に従ってアプリケーションをインストールします。
これらの手順では、正しい Fargate プロファイルを使用して新しいクラスターを作成することを前提としています。既に設定済みの Amazon EKS クラスターを使用する場合は、次のコマンドを使用して、このデモンストレーション用にそのクラスターを設定できます。*MyCluster* をクラスターの名前に置き換えます。
```
eksctl create iamserviceaccount --cluster MyCluster \
--namespace howto-k8s-fargate \
--name appmesh-pod \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshEnvoyAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapDiscoverInstanceAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess \
--override-existing-serviceaccounts \
--approve
```
```
eksctl create fargateprofile --cluster MyCluster \
--namespace howto-k8s-fargate --name howto-k8s-fargate
```
1. フロントアプリケーションのデプロイをポート転送します。
```
kubectl -n howto-k8s-fargate port-forward deployment/front 8080:8080
```
1. フロントアプリをカールする:
```
while true; do curl -s http://localhost:8080/color; sleep 0.1; echo ; done
```
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. クラスターが実行されている AWS リージョンで、ナビゲーションペインから [**Metrics**] (メトリクス) を選択します。このメトリクスは、[**ContainerInsights/Prometheus**] 名前空間にあります。
1. CloudWatch Logs イベントを表示するには、ナビゲーションペインで [**Log Groups (ロググループ)**] を選択します。イベントは、ログストリーム ` /aws/containerinsights/your_cluster_name/prometheus ` のロググループ `kubernetes-pod-appmesh-envoy` にあります 。
## App Mesh テスト環境の削除
App Mesh とサンプルアプリケーションの使用が終了したら、次のコマンドを使用して不要なリソースを削除します。サンプルアプリケーションを削除するには、次のコマンドを入力します。
```
cd aws-app-mesh-examples/walkthroughs/howto-k8s-fargate/
kubectl delete -f _output/manifest.yaml
```
App Mesh コントローラーを削除するには、次のコマンドを入力します。
```
helm delete appmesh-controller -n appmesh-system
```
# サンプルトラフィックを使用して、Amazon EKS および Kubernetes で NGINX をセットアップする
NGINX は、ロードバランサーやリバースプロキシとしても使用できるウェブサーバーです。Kubernetes が入力に NGINX を使用する方法については、「[kubernetes/ingress-nginx](https://github.com/kubernetes/ingress-nginx)」を参照してください。
**Container Insights の Prometheus サポートをテストするために、サンプルトラフィックサービス ingress-nginx をインストールするには**
1. 次のコマンドを入力して、Helm ingress-nginx リポジトリを追加します。
```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
```
1. 以下のコマンドを入力します。
```
kubectl create namespace nginx-ingress-sample
helm install my-nginx ingress-nginx/ingress-nginx \
--namespace nginx-ingress-sample \
--set controller.metrics.enabled=true \
--set-string controller.metrics.service.annotations."prometheus\.io/port"="10254" \
--set-string controller.metrics.service.annotations."prometheus\.io/scrape"="true"
```
1. 次のコマンドを入力して、サービスが正常に開始されたかどうかを確認します。
```
kubectl get service -n nginx-ingress-sample
```
このコマンドの出力には、`EXTERNAL-IP` 列を含む複数の列が表示されます。
1. NGINX 入力コントローラーの行の `EXTERNAL-IP` 列の値に `EXTERNAL-IP` 変数を設定します。
```
EXTERNAL_IP=your-nginx-controller-external-ip
```
1. 次のコマンドを入力して、サンプル NGINX トラフィックを開始します。
```
SAMPLE_TRAFFIC_NAMESPACE=nginx-sample-traffic
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_traffic/nginx-traffic/nginx-traffic-sample.yaml |
sed "s/{{external_ip}}/$EXTERNAL_IP/g" |
sed "s/{{namespace}}/$SAMPLE_TRAFFIC_NAMESPACE/g" |
kubectl apply -f -
```
1. 次のコマンドを入力して、3 つのポッドがすべて `Running` ステータスであることを確認します。
```
kubectl get pod -n $SAMPLE_TRAFFIC_NAMESPACE
```
ポッドが実行中の場合は、**ContainerInsights/Prometheus** 名前空間にメトリクスが表示されます。
**NGINX とサンプルトラフィックアプリケーションをアンインストールするには**
1. 次のコマンドを入力して、サンプルトラフィックサービスを削除します。
```
kubectl delete namespace $SAMPLE_TRAFFIC_NAMESPACE
```
1. Helm リリース名で NGINX egress を削除します。
```
helm uninstall my-nginx --namespace nginx-ingress-sample
kubectl delete namespace nginx-ingress-sample
```
# メトリクスエクスポーターを使用して、Amazon EKS および Kubernetes で memcached をセットアップする
memcached は、オープンソースのメモリオブジェクトキャッシュシステムです。詳細については、「[Memcached とは](https://www.memcached.org)」を参照してください。
Fargate 起動タイプのクラスターで memcached を実行している場合は、この手順の各ステップを実行する前に Fargate プロファイルを設定する必要があります。プロファイルを設定するには、次のコマンドを入力します。*MyCluster* をクラスターの名前に置き換えます。
```
eksctl create fargateprofile --cluster MyCluster \
--namespace memcached-sample --name memcached-sample
```
**メトリクスエクスポーターとともに memcached をインストールして、Container Insights の Prometheus サポートをテストするには**
1. 次のコマンドを入力して、リポジトリを追加します。
```
helm repo add bitnami https://charts.bitnami.com/bitnami
```
1. 以下のコマンドを入力して、新しい名前空間を作成します。
```
kubectl create namespace memcached-sample
```
1. 次のコマンドを入力して、Memcached をインストールします。
```
helm install my-memcached bitnami/memcached --namespace memcached-sample \
--set metrics.enabled=true \
--set-string serviceAnnotations.prometheus\\.io/port="9150" \
--set-string serviceAnnotations.prometheus\\.io/scrape="true"
```
1. 次のコマンドを入力して、実行中のサービスの注釈を確認します。
```
kubectl describe service my-memcached-metrics -n memcached-sample
```
次の 2 つの注釈が表示されます。
```
Annotations: prometheus.io/port: 9150
prometheus.io/scrape: true
```
**memcached をアンインストールするには**
+ 以下のコマンドを入力します。
```
helm uninstall my-memcached --namespace memcached-sample
kubectl delete namespace memcached-sample
```
# Amazon EKS および Kubernetes で Java/JMX サンプルワークロードをセットアップする
JMX Exporter は、Prometheus メトリクスとして JMX mBeans をスクレイプおよび公開できる公式の Prometheus エクスポーターです。詳細については、[prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter) を参照してください。
Container Insights は、JMX Exporter を使用して、Java 仮想マシン (JVM)、Java、および Tomcat (Catalina) から定義済みの Prometheus メトリクスを収集できます。
## デフォルトの Prometheus スクレイピング設定
デフォルトでは、Prometheus をサポートする CloudWatch エージェントは、Amazon EKS または Kubernetes クラスター内の各ポッドの `http://CLUSTER_IP:9404/metrics` から Java/JMX Prometheus メトリクスをスクレイプします。これは、Prometheus `kubernetes_sd_config` の `role: pod` 検出によって行われます。9404 は、Prometheus によって JMX Exporter に割り当てられたデフォルトのポートです。`role: pod` 検出の詳細については、「[ポッド](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#pod)」を参照してください。別のポートまたは metrics\$1path でメトリクスを公開するように JMX Exporter を設定できます。ポートまたはパスを変更する場合は、CloudWatch エージェント設定マップのデフォルトの jmx scrape\$1config を更新します。次のコマンドを実行して、現在の CloudWatch エージェント Prometheus 設定を取得します。
```
kubectl describe cm prometheus-config -n amazon-cloudwatch
```
変更するフィールドは、次の例で強調表示されているように、`/metrics` および `regex: '.*:9404$'` フィールドです。
```
job_name: 'kubernetes-jmx-pod'
sample_limit: 10000
metrics_path: /metrics
kubernetes_sd_configs:
- role: pod
relabel_configs:
- source_labels: [__address__]
action: keep
regex: '.*:9404$'
- action: replace
regex: (.+)
source_labels:
```
## その他の Prometheus スクレイピング設定
Kubernetes サービスによって、Java/JMX Prometheus エクスポーターを使用して一連の Pod で実行されているアプリケーションを公開する場合、Prometheus `role: service` の `role: endpoint` 検出または `kubernetes_sd_config` を使用するように切り替えることもできます。これらの検出方法の詳細については、「[ サービス](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#service)」、「[ エンドポイント](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#endpoints)」および「[](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#kubernetes_sd_config)」を参照してください。
これら 2 つのサービス検出モードによって、より多くのメタラベルが提供されるため、CloudWatch メトリクスディメンションを構築するのに便利です。たとえば、`__meta_kubernetes_service_name` ラベルを `Service` ラベルに書き換えてメトリクスのディメンションに含めることができます。CloudWatch メトリクスとそのディメンションのカスタマイズの詳細については、「[Prometheus の CloudWatch エージェント設定](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config)」を参照してください。
## JMX Exporter を使用した Docker イメージ
次に、Docker イメージを構築します。次のセクションでは、Dockerfile の例を 2 つ示します。
イメージを構築したら、Amazon EKS または Kubernetes にロードし、次のコマンドを実行して Prometheus メトリクスがポート 9404 で `JMX_EXPORTER` によって公開されていることを確認します。*\$1JAR\$1SAMPLE\$1TRAFFIC\$1POD* を実行中のポッド名に置き換え、*\$1JAR\$1SAMPLE\$1TRAFFIC\$1NAMESPACE* をアプリケーション名前空間に置き換えます。
Fargate 起動タイプのクラスターで JMX Exporter を実行している場合は、この手順の各ステップを実行する前に Fargate プロファイルも設定する必要があります。プロファイルを設定するには、次のコマンドを入力します。*MyCluster* をクラスターの名前に置き換えます。
```
eksctl create fargateprofile --cluster MyCluster \
--namespace $JAR_SAMPLE_TRAFFIC_NAMESPACE\
--name $JAR_SAMPLE_TRAFFIC_NAMESPACE
```
```
kubectl exec $JAR_SAMPLE_TRAFFIC_POD -n $JARCAT_SAMPLE_TRAFFIC_NAMESPACE -- curl http://localhost:9404
```
## 例: Prometheus メトリクスを使用した Apache Tomcat Docker イメージ
Apache Tomcat サーバーは、デフォルトで JMX mBeans を公開します。JMX Exporter と Tomcat を統合して、JMX mBeans を Prometheus メトリクスとして公開できます。次の例の Dockerfile は、テスト用イメージを構築するステップを示しています。
```
# From Tomcat 9.0 JDK8 OpenJDK
FROM tomcat:9.0-jdk8-openjdk
RUN mkdir -p /opt/jmx_exporter
COPY ./jmx_prometheus_javaagent-0.12.0.jar /opt/jmx_exporter
COPY ./config.yaml /opt/jmx_exporter
COPY ./setenv.sh /usr/local/tomcat/bin
COPY your web application.war /usr/local/tomcat/webapps/
RUN chmod o+x /usr/local/tomcat/bin/setenv.sh
ENTRYPOINT ["catalina.sh", "run"]
```
次のリストでは、この Dockerfile の 4 つの `COPY` 行について説明します。
+ [https://github.com/prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter) から最新の JMX Exporter jar ファイルをダウンロードします。
+ `config.yaml` は JMX Exporter 設定ファイルです。詳細については、[https://github.com/prometheus/jmx\$1exporter\$1Configuration](https://github.com/prometheus/jmx_exporter#Configuration ) を参照してください。
Java と Tomcat の設定ファイルのサンプルを次に示します。
```
lowercaseOutputName: true
lowercaseOutputLabelNames: true
rules:
- pattern: 'java.lang<>(FreePhysicalMemorySize|TotalPhysicalMemorySize|FreeSwapSpaceSize|TotalSwapSpaceSize|SystemCpuLoad|ProcessCpuLoad|OpenFileDescriptorCount|AvailableProcessors)'
name: java_lang_OperatingSystem_$1
type: GAUGE
- pattern: 'java.lang<>(TotalStartedThreadCount|ThreadCount)'
name: java_lang_threading_$1
type: GAUGE
- pattern: 'Catalina<>(\w+)'
name: catalina_globalrequestprocessor_$3_total
labels:
port: "$2"
protocol: "$1"
help: Catalina global $3
type: COUNTER
- pattern: 'Catalina<>(requestCount|maxTime|processingTime|errorCount)'
name: catalina_servlet_$3_total
labels:
module: "$1"
servlet: "$2"
help: Catalina servlet $3 total
type: COUNTER
- pattern: 'Catalina<>(currentThreadCount|currentThreadsBusy|keepAliveCount|pollerThreadCount|connectionCount)'
name: catalina_threadpool_$3
labels:
port: "$2"
protocol: "$1"
help: Catalina threadpool $3
type: GAUGE
- pattern: 'Catalina<>(processingTime|sessionCounter|rejectedSessions|expiredSessions)'
name: catalina_session_$3_total
labels:
context: "$2"
host: "$1"
help: Catalina session $3 total
type: COUNTER
- pattern: ".*"
```
+ `setenv.sh` は、Tomcat とともに JMX Exporter を起動し、ローカルホストのポート 9404 で Prometheus メトリクスを公開する Tomcat 起動スクリプトです。また、`config.yaml` ファイルパスを JMX Exporter に提供します。
```
$ cat setenv.sh
export JAVA_OPTS="-javaagent:/opt/jmx_exporter/jmx_prometheus_javaagent-0.12.0.jar=9404:/opt/jmx_exporter/config.yaml $JAVA_OPTS"
```
+ ウェブアプリケーション.war は、Tomcat によってロードされるウェブアプリケーション `war` ファイルです。
この設定で Docker イメージを構築し、イメージリポジトリにアップロードします。
## 例: Prometheus メトリクスを使用した Java Jar アプリケーション Docker イメージ
次の例の Dockerfile は、テスト用イメージを構築するステップを示しています。
```
# Alpine Linux with OpenJDK JRE
FROM openjdk:8-jre-alpine
RUN mkdir -p /opt/jmx_exporter
COPY ./jmx_prometheus_javaagent-0.12.0.jar /opt/jmx_exporter
COPY ./SampleJavaApplication-1.0-SNAPSHOT.jar /opt/jmx_exporter
COPY ./start_exporter_example.sh /opt/jmx_exporter
COPY ./config.yaml /opt/jmx_exporter
RUN chmod -R o+x /opt/jmx_exporter
RUN apk add curl
ENTRYPOINT exec /opt/jmx_exporter/start_exporter_example.sh
```
次のリストでは、この Dockerfile の 4 つの `COPY` 行について説明します。
+ [https://github.com/prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter) から最新の JMX Exporter jar ファイルをダウンロードします。
+ `config.yaml` は JMX Exporter 設定ファイルです。詳細については、[https://github.com/prometheus/jmx\$1exporter\$1Configuration](https://github.com/prometheus/jmx_exporter#Configuration ) を参照してください。
Java と Tomcat の設定ファイルのサンプルを次に示します。
```
lowercaseOutputName: true
lowercaseOutputLabelNames: true
rules:
- pattern: 'java.lang<>(FreePhysicalMemorySize|TotalPhysicalMemorySize|FreeSwapSpaceSize|TotalSwapSpaceSize|SystemCpuLoad|ProcessCpuLoad|OpenFileDescriptorCount|AvailableProcessors)'
name: java_lang_OperatingSystem_$1
type: GAUGE
- pattern: 'java.lang<>(TotalStartedThreadCount|ThreadCount)'
name: java_lang_threading_$1
type: GAUGE
- pattern: 'Catalina<>(\w+)'
name: catalina_globalrequestprocessor_$3_total
labels:
port: "$2"
protocol: "$1"
help: Catalina global $3
type: COUNTER
- pattern: 'Catalina<>(requestCount|maxTime|processingTime|errorCount)'
name: catalina_servlet_$3_total
labels:
module: "$1"
servlet: "$2"
help: Catalina servlet $3 total
type: COUNTER
- pattern: 'Catalina<>(currentThreadCount|currentThreadsBusy|keepAliveCount|pollerThreadCount|connectionCount)'
name: catalina_threadpool_$3
labels:
port: "$2"
protocol: "$1"
help: Catalina threadpool $3
type: GAUGE
- pattern: 'Catalina<>(processingTime|sessionCounter|rejectedSessions|expiredSessions)'
name: catalina_session_$3_total
labels:
context: "$2"
host: "$1"
help: Catalina session $3 total
type: COUNTER
- pattern: ".*"
```
+ `start_exporter_example.sh` は、エクスポートされた Prometheus メトリクスを使用して JAR アプリケーションを起動するスクリプトです。また、`config.yaml` ファイルパスを JMX Exporter に提供します。
```
$ cat start_exporter_example.sh
java -javaagent:/opt/jmx_exporter/jmx_prometheus_javaagent-0.12.0.jar=9404:/opt/jmx_exporter/config.yaml -cp /opt/jmx_exporter/SampleJavaApplication-1.0-SNAPSHOT.jar com.gubupt.sample.app.App
```
+ SampleJavaApplication-1.0-SNAPSHOT.jar は、Java アプリケーションのサンプル jar ファイルです。このファイルを、モニターリングする Java アプリケーションに置き換えます。
この設定で Docker イメージを構築し、イメージリポジトリにアップロードします。
# メトリクスエクスポーターを使用して、Amazon EKS および Kubernetes で HAProxy をセットアップする
HAProxy は、オープンソースのプロキシアプリケーションです。詳細については、「[HAProxy](https://www.haproxy.org)」を参照してください。
Fargate 起動タイプのクラスターで HAProxy を実行している場合は、この手順の各ステップを実行する前に Fargate プロファイルを設定する必要があります。プロファイルを設定するには、次のコマンドを入力します。*MyCluster* をクラスターの名前に置き換えます。
```
eksctl create fargateprofile --cluster MyCluster \
--namespace haproxy-ingress-sample --name haproxy-ingress-sample
```
**メトリクスエクスポーターとともに HAProxy をインストールして、Container Insights の Prometheus サポートをテストするには**
1. 次のコマンドを入力して、Helm インキュベーターレポジトリを追加します。
```
helm repo add haproxy-ingress https://haproxy-ingress.github.io/charts
```
1. 以下のコマンドを入力して、新しい名前空間を作成します。
```
kubectl create namespace haproxy-ingress-sample
```
1. 次のコマンドを入力して、HAProxy をインストールします。
```
helm install haproxy haproxy-ingress/haproxy-ingress \
--namespace haproxy-ingress-sample \
--set defaultBackend.enabled=true \
--set controller.stats.enabled=true \
--set controller.metrics.enabled=true \
--set-string controller.metrics.service.annotations."prometheus\.io/port"="9101" \
--set-string controller.metrics.service.annotations."prometheus\.io/scrape"="true"
```
1. 次のコマンドを入力して、サービスの注釈を確認します。
```
kubectl describe service haproxy-haproxy-ingress-metrics -n haproxy-ingress-sample
```
次の注釈が表示されます。
```
Annotations: prometheus.io/port: 9101
prometheus.io/scrape: true
```
**HAProxy をアンインストールするには**
+ 以下のコマンドを入力します。
```
helm uninstall haproxy --namespace haproxy-ingress-sample
kubectl delete namespace haproxy-ingress-sample
```
# Prometheus スクレイピングの新しいターゲットの追加に関するチュートリアル: Amazon EKS クラスターと Kubernetes クラスター上の Redis OSS
このチュートリアルでは、Amazon EKS および Kubernetes 上のサンプル Redis OSS アプリケーションにおける Prometheus メトリクスをスクレイピングする方法を実践的に説明します。Redis OSS (https://redis.io/) は、オープンソース (BSD ライセンス適用) のインメモリ型のデータ構造ストアで、データベース、キャッシュ、メッセージブローカーとして使用されます。詳細については、「[redis](https://redis.io/)」を参照してください。
redis\$1exporter (MIT ライセンス適用) は、指定されたポート (デフォルト: 0.0.0.0:9121) で Redis OSS Prometheus メトリクスを公開するために使用します。詳細については、「[redis\$1exporter](https://github.com/oliver006/redis_exporter)」を参照してください。
このチュートリアルでは、次の 2 つの Docker ハブリポジトリの Docker イメージを使用します。
+ [redis](https://hub.docker.com/_/redis?tab=description)
+ [redis\$1exporter](https://hub.docker.com/r/oliver006/redis_exporter)
**Prometheus メトリクスを公開するサンプル Redis OSS ワークロードをインストールするには**
1. サンプル Redis OSS ワークロードの名前空間を設定します。
```
REDIS_NAMESPACE=redis-sample
```
1. Fargate 起動タイプのクラスター上で Redis OSS を実行している場合は、Fargate プロファイルを設定する必要があります。プロファイルを設定するには、次のコマンドを入力します。*MyCluster* をクラスターの名前に置き換えます。
```
eksctl create fargateprofile --cluster MyCluster \
--namespace $REDIS_NAMESPACE --name $REDIS_NAMESPACE
```
1. 次のコマンドを入力して、サンプル Redis OSS ワークロードをインストールします。
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_traffic/redis/redis-traffic-sample.yaml \
| sed "s/{{namespace}}/$REDIS_NAMESPACE/g" \
| kubectl apply -f -
```
1. インストールには、ポート 9121 で Redis OSS Prometheus メトリクスを公開する、`my-redis-metrics` という名前のサービスが含まれています。サービスの詳細を取得するには、次のコマンドを入力します。
```
kubectl describe service/my-redis-metrics -n $REDIS_NAMESPACE
```
結果の `Annotations` セクションには、CloudWatch エージェントの Prometheus スクレイプ設定に一致する 2 つの注釈が表示されます。これにより、ワークロードを自動検出できます。
```
prometheus.io/port: 9121
prometheus.io/scrape: true
```
関連する Prometheus スクレイプの設定は、`- job_name: kubernetes-service-endpoints` または `kubernetes-eks.yaml` の `kubernetes-k8s.yaml` のセクションに記載されています。
**CloudWatch で Redis OSS Prometheus メトリクスの収集を開始するには**
1. 次のコマンドのいずれかを入力して、最新バージョンの `kubernetes-eks.yaml` または `kubernetes-k8s.yaml` ファイルをダウンロードします。EC2 起動タイプの Amazon EKS クラスターの場合は、次のコマンドを入力します。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml
```
Fargate 起動タイプの Amazon EKS クラスターの場合は、次のコマンドを入力します。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml
```
Amazon EC2 インスタンスで実行されている Kubernetes クラスターの場合は、このコマンドを入力します。
```
curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml
```
1. テキストエディタでファイルを開き、`cwagentconfig.json` セクションを見つけます。次のサブセクションを追加し、変更を保存します。インデントが既存のパターンに従っていることを確認してください。
```
{
"source_labels": ["pod_name"],
"label_matcher": "^redis-instance$",
"dimensions": [["Namespace","ClusterName"]],
"metric_selectors": [
"^redis_net_(in|out)put_bytes_total$",
"^redis_(expired|evicted)_keys_total$",
"^redis_keyspace_(hits|misses)_total$",
"^redis_memory_used_bytes$",
"^redis_connected_clients$"
]
},
{
"source_labels": ["pod_name"],
"label_matcher": "^redis-instance$",
"dimensions": [["Namespace","ClusterName","cmd"]],
"metric_selectors": [
"^redis_commands_total$"
]
},
{
"source_labels": ["pod_name"],
"label_matcher": "^redis-instance$",
"dimensions": [["Namespace","ClusterName","db"]],
"metric_selectors": [
"^redis_db_keys$"
]
},
```
セクションの追加により、Redis OSS メトリクスが CloudWatch エージェントの許可リストに配置されます。これらのメトリクスのリストについては、次のセクションを参照してください。
1. Prometheus をサポートする CloudWatch エージェントが既にこのクラスターにデプロイされている場合は、次のコマンドを入力してエージェントを削除する必要があります。
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
```
1. 次のいずれかのコマンドを入力して、更新した設定で CloudWatch エージェントをデプロイします。*MyCluster* と *リージョン*を設定に合わせて置き換えます。
EC2 起動タイプの Amazon EKS クラスターの場合は、次のコマンドを入力します。
```
kubectl apply -f prometheus-eks.yaml
```
Fargate 起動タイプの Amazon EKS クラスターの場合は、次のコマンドを入力します。
```
cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
Kubernetes クラスターの場合は、このコマンドを入力します。
```
cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -
```
## Redis OSS Prometheus メトリクスの表示
このチュートリアルでは、次のメトリクスを CloudWatch の **ContainerInsights/Prometheus** 名前空間に送信します。CloudWatch コンソールを使用して、その名前空間のメトリクスを表示できます。
| メトリクス名 | ディメンション |
| --- | --- |
| `redis_net_input_bytes_total` | ClusterName、`Namespace` |
| `redis_net_output_bytes_total` | ClusterName、`Namespace` |
| `redis_expired_keys_total` | ClusterName、`Namespace` |
| `redis_evicted_keys_total` | ClusterName、`Namespace` |
| `redis_keyspace_hits_total` | ClusterName、`Namespace` |
| `redis_keyspace_misses_total` | ClusterName、`Namespace` |
| `redis_memory_used_bytes` | ClusterName、`Namespace` |
| `redis_connected_clients` | ClusterName、`Namespace` |
| `redis_commands_total` | ClusterName、`Namespace`、cmd |
| `redis_db_keys` | ClusterName、`Namespace`、db |
**注記**
**cmd** ディメンションの値には `append`、`client`、`command`、`config`、`dbsize`、`flushall`、`get`、`incr`、`info`、`latency`、または `slowlog` を指定できます。
**db** ディメンションの値は `db0` から `db15` に指定できます。
また、Redis OSS Prometheus メトリクスの CloudWatch ダッシュボードを作成することもできます。
**Redis OSS Prometheus メトリクスのダッシュボードを作成するには**
1. 環境変数を作成し、以下の値をデプロイに合わせて置き換えます。
```
DASHBOARD_NAME=your_cw_dashboard_name
REGION_NAME=your_metric_region_such_as_us-east-1
CLUSTER_NAME=your_k8s_cluster_name_here
NAMESPACE=your_redis_service_namespace_here
```
1. 次のコマンドを入力して、ダッシュボードを作成します。
```
curl https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/redis/cw_dashboard_redis.json \
| sed "s/{{YOUR_AWS_REGION}}/${REGION_NAME}/g" \
| sed "s/{{YOUR_CLUSTER_NAME}}/${CLUSTER_NAME}/g" \
| sed "s/{{YOUR_NAMESPACE}}/${NAMESPACE}/g" \
```
# CloudWatch エージェントによる Prometheus メトリクスタイプの変換
Prometheus クライアントライブラリには、次の 4 つのコアメトリクスタイプがあります。
+ Counter
+ Gauge
+ 概要
+ Histogram
CloudWatch エージェントは、カウンター、ゲージ、サマリーメトリクスタイプをサポートします。
サポートされていないヒストグラムメトリクスタイプの Prometheus メトリクスは、CloudWatch エージェントによって除外されます。詳細については、「[削除された Prometheus メトリクスのログ記録](ContainerInsights-Prometheus-troubleshooting-EKS.md#ContainerInsights-Prometheus-troubleshooting-droppedmetrics)」を参照してください。
**ゲージメトリクス**
プロメテウスゲージメトリクス (Prometheus gauge metric) とは、任意に上下できる単一の数値を表すメトリクスです。CloudWatch エージェントはゲージメトリクスをスクレイプし、これらの値を直接送信します。
**カウンターメトリクス**
Prometheus カウンターメトリクスは、値を増加またはゼロにリセットすることができる単一の単調増加カウンターを表す累積メトリクスです。CloudWatch エージェントは、前回のスクレイプからデルタを計算し、ログイベントのメトリクス値としてデルタ値を送信します。したがって、CloudWatch エージェントは 2 回目のスクレイプから 1 つのログイベントを生成し始め、後続のスクラップがあれば続行します。
**サマリーメトリクス**
Prometheus サマリーメトリクスは、複数のデータポイントによって表される複雑なメトリクスタイプです。これは、観測値の合計数とすべての観測値の合計を提供します。スライドのタイムウィンドウで設定可能な分位数を計算します。
サマリーメトリクスの合計とカウントは累積されますが、分位数は累積されません。次の例は、分位数の分散を示しています。
```
# TYPE go_gc_duration_seconds summary
go_gc_duration_seconds{quantile="0"} 7.123e-06
go_gc_duration_seconds{quantile="0.25"} 9.204e-06
go_gc_duration_seconds{quantile="0.5"} 1.1065e-05
go_gc_duration_seconds{quantile="0.75"} 2.8731e-05
go_gc_duration_seconds{quantile="1"} 0.003841496
go_gc_duration_seconds_sum 0.37630427
go_gc_duration_seconds_count 9774
```
前のセクションで説明したように、CloudWatch エージェントはカウンターメトリクスを処理するのと同じ方法で、サマリーメトリクスの合計とカウントを処理します。CloudWatch エージェントは、最初に報告された分位数の値を保持します。
# CloudWatch エージェントにより収集される Prometheus メトリクス
Prometheus をサポートする CloudWatch エージェントは、複数のサービスとワークロードからメトリクスを自動的に収集します。デフォルトで収集されるメトリクスは、次のセクションに表示されます。これらのサービスから収集するメトリクスを増やし、他のアプリケーションやサービスから Prometheus メトリクスを収集するようにエージェントを設定することもできます。追加メトリクスの収集の詳細については、「[Prometheus の CloudWatch エージェント設定](ContainerInsights-Prometheus-Setup-configure-ECS.md#ContainerInsights-Prometheus-Setup-cw-agent-config)」を参照してください。
Amazon EKS および Kubernetes クラスターから収集された Prometheus メトリクスは、[**ContainerInsights/Prometheus**] 名前空間にあります。Amazon ECS クラスターから収集された Prometheus メトリクスは、 [**ECS/ContainerInsights/Prometheus**] 名前空間にあります。
**Topics**
+ [App Mesh の Prometheus メトリクス](#ContainerInsights-Prometheus-metrics-appmesh)
+ [NGINX の Prometheus メトリクス](#ContainerInsights-Prometheus-metrics-nginx)
+ [memcached の Prometheus メトリクス](#ContainerInsights-Prometheus-metrics-memcached)
+ [Java/JMX の Prometheus メトリクス](#ContainerInsights-Prometheus-metrics-jmx)
+ [HAProxy の Prometheus メトリクス](#ContainerInsights-Prometheus-metrics-haproxy)
## App Mesh の Prometheus メトリクス
次のメトリクスは App Mesh から自動的に収集されます。
**Amazon EKS クラスターおよび Kubernetes クラスターでの App Mesh の Prometheus メトリクス**
| メトリクス名 | ディメンション |
| --- | --- |
| `envoy_http_downstream_rq_total` | ClusterName、`Namespace` |
| `envoy_http_downstream_rq_xx` | ClusterName、`Namespace` ClusterName、`Namespace`、envoy\$1http\$1conn\$1manager\$1prefix、envoy\$1response\$1code\$1class |
| `envoy_cluster_upstream_cx_rx_bytes_total` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_cx_tx_bytes_total` | ClusterName、`Namespace` |
| `envoy_cluster_membership_healthy` | ClusterName、`Namespace` |
| `envoy_cluster_membership_total` | ClusterName、`Namespace` |
| `envoy_server_memory_heap_size` | ClusterName、`Namespace` |
| `envoy_server_memory_allocated` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_cx_connect_timeout` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_rq_pending_failure_eject` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_rq_pending_overflow` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_rq_timeout` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_rq_try_per_timeout` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_rq_rx_reset` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_cx_destroy_local_with_active_rq` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_cx_destroy_remote_active_rq` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_rq_maintenance_mode` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_flow_control_paused_reading_total` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_flow_control_resumed_reading_total` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_flow_control_backed_up_total` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_flow_control_drained_total` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_rq_retry` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_rq_retry_success` | ClusterName、`Namespace` |
| `envoy_cluster_upstream_rq_retry_overflow` | ClusterName、`Namespace` |
| `envoy_server_live` | ClusterName、`Namespace` |
| `envoy_server_uptime` | ClusterName、`Namespace` |
**Amazon ECS クラスターでの App Mesh の Prometheus メトリクス**
| メトリクス名 | ディメンション |
| --- | --- |
| `envoy_http_downstream_rq_total` | ClusterName、`TaskDefinitionFamily` |
| `envoy_http_downstream_rq_xx` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_rx_bytes_total` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_tx_bytes_total` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_membership_healthy` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_membership_total` | ClusterName、`TaskDefinitionFamily` |
| `envoy_server_memory_heap_size` | ClusterName、`TaskDefinitionFamily` |
| `envoy_server_memory_allocated` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_connect_timeout` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_pending_failure_eject` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_pending_overflow` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_timeout` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_try_per_timeout` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_rx_reset` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_destroy_local_with_active_rq` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_cx_destroy_remote_active_rq` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_maintenance_mode` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_flow_control_paused_reading_total` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_flow_control_resumed_reading_total` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_flow_control_backed_up_total` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_flow_control_drained_total` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_retry` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_retry_success` | ClusterName、`TaskDefinitionFamily` |
| `envoy_cluster_upstream_rq_retry_overflow` | ClusterName、`TaskDefinitionFamily` |
| `envoy_server_live` | ClusterName、`TaskDefinitionFamily` |
| `envoy_server_uptime` | ClusterName、`TaskDefinitionFamily` |
| `envoy_http_downstream_rq_xx` | ClusterName, TaskDefinitionFamily, envoy\$1http\$1conn\$1manager\$1prefix, envoy\$1response\$1code\$1class ClusterName, TaskDefinitionFamily, envoy\$1response\$1code\$1class |
**注記**
`TaskDefinitionFamily` は、メッシュの Kubernetes 名前空間です。
`envoy_http_conn_manager_prefix` の値は、`ingress`、`egress`、または `admin` のいずれかです。
`envoy_response_code_class` の値は、 `1` (`1xx` を意味する)、`2` (`2xx` を意味する)、`3` (`3xx` を意味する)、 `4` (`4xx` を意味する)、 `5` (`5xx` を意味する) のいずれかです。
## NGINX の Prometheus メトリクス
次のメトリクスは、Amazon EKS および Kubernetes クラスターの NGINX から自動的に収集されます。
| メトリクス名 | ディメンション |
| --- | --- |
| `nginx_ingress_controller_nginx_process_cpu_seconds_total` | ClusterName、`Namespace`、Service |
| `nginx_ingress_controller_success` | ClusterName、`Namespace`、Service |
| `nginx_ingress_controller_requests` | ClusterName、`Namespace`、Service |
| `nginx_ingress_controller_nginx_process_connections` | ClusterName、`Namespace`、Service |
| `nginx_ingress_controller_nginx_process_connections_total` | ClusterName、`Namespace`、Service |
| `nginx_ingress_controller_nginx_process_resident_memory_bytes` | ClusterName、`Namespace`、Service |
| `nginx_ingress_controller_config_last_reload_successful` | ClusterName、`Namespace`、Service |
| `nginx_ingress_controller_requests` | ClusterName、`Namespace`、Service、ステータス |
## memcached の Prometheus メトリクス
以下のメトリクスは、Amazon EKS および Kubernetes クラスターの memcached から自動的に収集されます。
| メトリクス名 | ディメンション |
| --- | --- |
| `memcached_current_items` | ClusterName、`Namespace`、Service |
| `memcached_current_connections` | ClusterName、`Namespace`、Service |
| `memcached_limit_bytes` | ClusterName、`Namespace`、Service |
| `memcached_current_bytes` | ClusterName、`Namespace`、Service |
| `memcached_written_bytes_total` | ClusterName、`Namespace`、Service |
| `memcached_read_bytes_total` | ClusterName、`Namespace`、Service |
| `memcached_items_evicted_total` | ClusterName、`Namespace`、Service |
| `memcached_items_reclaimed_total` | ClusterName、`Namespace`、Service |
| `memcached_commands_total` | ClusterName、`Namespace`、Service ClusterName、`Namespace`、Service、コマンド ClusterName、`Namespace`、Service、ステータス、コマンド |
## Java/JMX の Prometheus メトリクス
**Amazon EKS および Kubernetes クラスターで収集されたメトリクス**
Container Insights は、Amazon EKS および Kubernetes クラスターで JMX Exporter を使用して、Java 仮想マシン (JVM)、Java、Tomcat (Catalina) から、次の定義済みの Prometheus メトリクスを収集できます。詳細については、Github の [prometheus/jmx\$1exporter](https://github.com/prometheus/jmx_exporter) を参照してください。
**Amazon EKS クラスターおよび Kubernetes クラスターでの Java/JMX**
| メトリクス名 | ディメンション |
| --- | --- |
| `jvm_classes_loaded` | `ClusterName`, `Namespace` |
| `jvm_threads_current` | `ClusterName`, `Namespace` |
| `jvm_threads_daemon` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_totalswapspacesize` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_systemcpuload` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_processcpuload` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_freeswapspacesize` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_totalphysicalmemorysize` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_freephysicalmemorysize` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_openfiledescriptorcount` | `ClusterName`, `Namespace` |
| `java_lang_operatingsystem_availableprocessors` | `ClusterName`, `Namespace` |
| `jvm_memory_bytes_used` | `ClusterName`、`Namespace`、エリア |
| `jvm_memory_pool_bytes_used` | `ClusterName`、`Namespace`、プール |
**注記**
`area` ディメンションの値は、`heap` または `nonheap` になります。
`pool` ディメンションの値は `Tenured Gen`、`Compress Class Space`、`Survivor Space`、`Eden Space`、`Code Cache`、または `Metaspace` のいずれかです。
**Amazon EKS および Kubernetes クラスター上の TomCAT/JMX**
前の表の Java/JMX メトリクスに加えて、Tomcat ワークロードに対して次のメトリクスも収集されます。
| メトリクス名 | ディメンション |
| --- | --- |
| `catalina_manager_activesessions` | `ClusterName`, `Namespace` |
| `catalina_manager_rejectedsessions` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_bytesreceived` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_bytessent` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_requestcount` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_errorcount` | `ClusterName`, `Namespace` |
| `catalina_globalrequestprocessor_processingtime` | `ClusterName`, `Namespace` |
**Amazon ECS クラスターの Java/JMX**
| メトリクス名 | ディメンション |
| --- | --- |
| `jvm_classes_loaded` | `ClusterName`, `TaskDefinitionFamily` |
| `jvm_threads_current` | `ClusterName`, `TaskDefinitionFamily` |
| `jvm_threads_daemon` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_totalswapspacesize` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_systemcpuload` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_processcpuload` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_freeswapspacesize` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_totalphysicalmemorysize` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_freephysicalmemorysize` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_openfiledescriptorcount` | `ClusterName`, `TaskDefinitionFamily` |
| `java_lang_operatingsystem_availableprocessors` | `ClusterName`, `TaskDefinitionFamily` |
| `jvm_memory_bytes_used` | `ClusterName`、TaskDefinitionFamily、エリア |
| `jvm_memory_pool_bytes_used` | `ClusterName`、TaskDefinitionFamily、プール |
**注記**
`area` ディメンションの値は、`heap` または `nonheap` になります。
`pool` ディメンションの値は `Tenured Gen`、`Compress Class Space`、`Survivor Space`、`Eden Space`、`Code Cache`、または `Metaspace` のいずれかです。
**Amazon ECS クラスターでの Tomcat/JMX**
前の表の Java/JMX メトリクスに加えて、Amazon ECS クラスターの Tomcat ワークロードに対して次のメトリクスも収集されます。
| メトリクス名 | ディメンション |
| --- | --- |
| `catalina_manager_activesessions` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_manager_rejectedsessions` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_bytesreceived` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_bytessent` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_requestcount` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_errorcount` | `ClusterName`, `TaskDefinitionFamily` |
| `catalina_globalrequestprocessor_processingtime` | `ClusterName`, `TaskDefinitionFamily` |
## HAProxy の Prometheus メトリクス
次のメトリクスは、Amazon EKS および Kubernetes クラスターの HAProxy から自動的に収集されます。
収集されるメトリクスは、使用している HAProxy Ingress のバージョンによって異なります。HAProxy Ingress とそのバージョンの詳細については、「[haproxy-ingress](https://artifacthub.io/packages/helm/haproxy-ingress/haproxy-ingress)」をご参照ください。
| メトリクス名 | ディメンション | 利用可能な状況 |
| --- | --- | --- |
| `haproxy_backend_bytes_in_total` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のすべてのバージョン |
| `haproxy_backend_bytes_out_total` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のすべてのバージョン |
| `haproxy_backend_connection_errors_total` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のすべてのバージョン |
| `haproxy_backend_connections_total` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のすべてのバージョン |
| `haproxy_backend_current_sessions` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のすべてのバージョン |
| `haproxy_backend_http_responses_total` | `ClusterName`、`Namespace`、Service、コード、バックエンド | HAProxy Ingress のすべてのバージョン |
| `haproxy_backend_status` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のバージョン 0.10 以降のみ |
| `haproxy_backend_up` | `ClusterName`、`Namespace`、Service | 0.10 より前のバージョンの HAProxy Ingress のみ |
| `haproxy_frontend_bytes_in_total` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のすべてのバージョン |
| `haproxy_frontend_bytes_out_total` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のすべてのバージョン |
| `haproxy_frontend_connections_total` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のすべてのバージョン |
| `haproxy_frontend_current_sessions` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のすべてのバージョン |
| `haproxy_frontend_http_requests_total` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のすべてのバージョン |
| `haproxy_frontend_http_responses_total` | `ClusterName`、`Namespace`、Service、コード、フロントエンド | HAProxy Ingress のすべてのバージョン |
| `haproxy_frontend_request_errors_total` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のすべてのバージョン |
| `haproxy_frontend_requests_denied_total` | `ClusterName`、`Namespace`、Service | HAProxy Ingress のすべてのバージョン |
**注記**
`code` ディメンションの値は `1xx`、`2xx`、`3xx`、`4xx`、`5xx`、または `other` のいずれかです。
`backend` ディメンションの値は次とすることができます:
HAProxy Ingress バージョン 0.0.27 以前用の `http-default-backend`、`http-shared-backend`、または `httpsback-shared-backend`。
`_default_backend`0.0.27 より後のバージョンの HAProxy Ingress の 。
`frontend` ディメンションの値は次とすることができます:
HAProxy Ingress バージョン 0.0.27 以前用の `httpfront-default-backend`、`httpfront-shared-frontend`、または `httpfronts`。
0.0.27 より後のバージョンの HAProxy Ingress の `_front_http` または `_front_https`。
# Prometheus メトリクスの表示
App Mesh、NGINX、Java/JMX、Memcached、HAProxy、およびユーザーが追加した手動設定の他の Prometheus エクスポーターから選別された事前集計メトリクスを含む、すべての Prometheus メトリクスについてモニターリングし、アラームを受けることができます。他の Prometheus エクスポーターからのメトリクス収集の詳細については、「[新しい Prometheus スクレイピングターゲットを追加するためのチュートリアル: Prometheus API サーバーメトリクス](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters)」を参照してください。
CloudWatch コンソールでは、Container Insights は次の事前作成済みのレポートを提供します。
+ Amazon EKS および Kubernetes クラスターの場合、App Mesh、NGINX、HAProxy、Memcached、Java/JMX 用の事前作成済みのレポートが提供されます。
+ Amazon ECS クラスターの場合、App Mesh と Java/JMX 用の事前作成済みレポートが提供されます。
また、Container Insights は、Container Insights が厳選したメトリクスを収集するワークロードごとにカスタムダッシュボードを提供します。これらのダッシュボードは GitHub からダウンロードすることができます
**Prometheus メトリクスをすべて表示するには**
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. ナビゲーションペインで [**Metrics (メトリクス)**] を選択してください。
1. 名前空間のリストで、[**ContainerInsights/Prometheus**] または [**ECS/ContainerInsights/Prometheus**] を選択します。
1. 次のリストで、ディメンションのセットの 1 つを選択します。次に、表示するメトリクスの横にあるチェックボックスを選択します。
**Prometheus メトリクスに関する事前作成済みのレポートを表示するには**
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. ナビゲーションペインで、[**パフォーマンスのモニターリング**] を選択します。
1. ページの上部近くのドロップダウンボックスで、Prometheus オプションのいずれかを選択します。
もう 1 つのドロップダウンボックスで、表示するクラスターを選択します。
また、NGINX、App Mesh、Memcached、HAProxy、Java/JMX 用のカスタムダッシュボードも用意されています。
**Amazon が用意したカスタムダッシュボードを使用するには**
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. ナビゲーションペインで、**ダッシュボード**を選択します。
1. [**ダッシュボードの作成**] を選択します。新しいダッシュボードの名前を入力し、[**ダッシュボードの作成**] を選択します。
1. [**このダッシュボードに追加**] で、[**キャンセル**] を選択します。
1. [**アクション**]、[**ソースの表示/編集**] を選択します。
1. 次の JSON ファイルのいずれかをダウンロードします。
+ [ Github の NGINX カスタムダッシュボードソース](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/nginx-ingress/cw_dashboard_nginx_ingress_controller.json)。
+ [Github の App Mesh カスタムダッシュボードソース](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/appmesh/cw_dashboard_awsappmesh.json)。
+ [ Github の Memcached カスタムダッシュボードソース](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/memcached/cw_dashboard_memcached.json)。
+ [ Github の HAProxy-Ingress カスタムダッシュボードソース](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/haproxy-ingress/cw_dashboard_haproxy_ingress.json)
+ [ Github の Java/JMX カスタムダッシュボードソース](https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/sample_cloudwatch_dashboards/javajmx/cw_dashboard_javajmx.json)。
1. ダウンロードした JSON ファイルをテキストエディタで開き、次の変更を加えます。
+ すべての `{{YOUR_CLUSTER_NAME}}` 文字列をクラスターの正確な名前に置き換えます。テキストの前後に空白を追加しないようにしてください。
+ すべての `{{YOUR_REGION}}` 文字列を、クラスターが実行されている AWS リージョンに置き換えます。例えば、**us-west-1** テキストの前後に空白を追加しないようにしてください。
+ すべての `{{YOUR_NAMESPACE}}` 文字列を、ワークロードとまったく同じ名前空間に置き換えます。
+ すべての `{{YOUR_SERVICE_NAME}}` 文字列を、ワークロードとまったく同じサービス名に置き換えます。例: **haproxy-haproxy-ingress-controller-metrics**
1. JSON BLOB 全体をコピーし、CloudWatch コンソールのテキストボックスに貼り付けて、ボックスに既に入力されている内容を置き換えます。
1. [**更新**]、[**ダッシュボードの保存**] の順に選択します。
# Prometheus メトリクスのトラブルシューティング
このセクションでは、Prometheus メトリクス設定のトラブルシューティングに役立つ情報を提供します。
**Topics**
+ [Amazon ECS での Prometheus メトリクスのトラブルシューティング](ContainerInsights-Prometheus-troubleshooting-ECS.md)
+ [Amazon EKS および Kubernetes クラスターでの Prometheus メトリクスのトラブルシューティング](ContainerInsights-Prometheus-troubleshooting-EKS.md)
# Amazon ECS での Prometheus メトリクスのトラブルシューティング
このセクションでは、クラスターの Amazon ECS での Prometheus メトリクス設定のトラブルシューティングに役立つ情報を提供します。
## CloudWatch Logs に送信された Prometheus メトリクスが表示されません
Prometheus メトリクスをロググループ **/aws/ecs/containerinsights/cluster-name/Prometheus** にログイベントとして取り込む必要があります。ロググループが作成されていない場合、または Prometheus メトリクスがロググループに送信されない場合は、Prometheus ターゲットが CloudWatch エージェントによって正常に検出されているかどうかを確認する必要があります。次に、CloudWatch エージェントのセキュリティグループとアクセス許可設定を確認します。次のステップは、デバッグを実行するためのガイドです。
**ステップ 1: CloudWatch エージェントのデバッグモードを有効にする**
最初に、CloudFormation テンプレートファイル、`cwagent-ecs-prometheus-metric-for-bridge-host.yaml` または `cwagent-ecs-prometheus-metric-for-awsvpc.yaml` に次の太字行を追加して、CloudWatch エージェントをデバッグモードに変更します。その後、ファイルを保存します。
```
cwagentconfig.json: |
{
"agent": {
"debug": true
},
"logs": {
"metrics_collected": {
```
既存のスタックに対して新しい CloudFormation 変更セットを作成します。変更セットの他のパラメータを、既存の CloudFormation スタックと同じ値に設定します。次の例は、EC2 起動タイプとブリッジネットワークモードを使用して Amazon ECS クラスターにインストールされた CloudWatch エージェントです。
```
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name
NEW_CHANGESET_NAME=your_selected_ecs_execution_role_name
aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
--template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
--parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
--capabilities CAPABILITY_NAMED_IAM \
--region $AWS_REGION \
--change-set-name $NEW_CHANGESET_NAME
```
CloudFormation コンソールに移動して、新しい変更セット、`$NEW_CHANGESET_NAME` を確認します。**CWAgentConfigSSMParameter** リソースには、1 つの変更が適用されている必要があります。次のコマンドを入力して、変更セットを実行し、CloudWatch エージェントタスクを再起動します。
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service your_service_name_here \
--region $AWS_REGION
```
10 秒ほど待ってから、次のコマンドを入力します。
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service your_service_name_here \
--region $AWS_REGION
```
**ステップ 2: ECS サービス検出ログを確認する**
CloudWatch エージェントの ECS タスク定義では、以下のセクションのログがデフォルトで有効になります。ログは、ロググループ **/ecs/ecs-cwagent-prometheus** の CloudWatch Logs に送信されます。
```
LogConfiguration:
LogDriver: awslogs
Options:
awslogs-create-group: 'True'
awslogs-group: "/ecs/ecs-cwagent-prometheus"
awslogs-region: !Ref AWS::Region
awslogs-stream-prefix: !Sub 'ecs-${ECSLaunchType}-awsvpc'
```
次の例に示すように、文字列 `ECS_SD_Stats` でログをフィルタリングして、ECS サービスの検出に関連するメトリクスを取得します。
```
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeContainerInstances: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeInstancesRequest: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeTaskDefinition: 2
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_DescribeTasks: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: AWSCLI_ListTasks: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: Exporter_DiscoveredTargetCount: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Get_EC2MetaData: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Get_TaskDefinition: 2
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Size_ContainerInstance: 1
2020-09-1T01:53:14Z D! ECS_SD_Stats: LRUCache_Size_TaskDefinition: 2
2020-09-1T01:53:14Z D! ECS_SD_Stats: Latency: 43.399783ms
```
特定の ECS サービス検出サイクルの各メトリクスの意味は次のとおりです。
+ **AWSCLI\$1DescribeContainerInstances** – 実行された `ECS::DescribeContainerInstances` API 呼び出しの数。
+ **AWSCLI\$1DescribeInstancesRequest** – 実行された `ECS::DescribeInstancesRequest` API 呼び出しの数。
+ **AWSCLI\$1DescribeTaskDefinition** – 実行された `ECS::DescribeTaskDefinition` API 呼び出しの数。
+ **AWSCLI\$1DescribeTasks** – 実行された `ECS::DescribeTasks` API 呼び出しの数。
+ **AWSCLI\$1ListTasks** – 実行された `ECS::ListTasks` API 呼び出しの数。
+ **ExporterDiscoveredTargetCount** – 検出され、コンテナ内のターゲット結果ファイルに正常にエクスポートされた Prometheus ターゲットの数。
+ **LRUCache\$1Get\$1EC2MetaData** – コンテナインスタンスのメタデータがキャッシュから取得された回数。
+ **LRUCache\$1Get\$1TaskDefinition** – ECS タスク定義メタデータがキャッシュから取得された回数。
+ **LRUCache\$1Size\$1ContainerInstance** – メモリにキャッシュされた一意のコンテナインスタンスのメタデータの数。
+ **LRUCache\$1Size\$1TaskDefinition** – メモリにキャッシュされた一意の ECS タスク定義の数。
+ **レイテンシー** – サービス検出サイクルに要する待ち時間。
`ExporterDiscoveredTargetCount` の値をチェックして、検出された Prometheus のターゲットが期待と一致しているかどうかを確認します。そうでない場合、考えられる理由は次のとおりです。
+ ECS サービス検出の設定が、アプリケーションの設定と一致していない可能性があります。Docker ラベルベースのサービス検出では、ターゲットコンテナに自動検出するために必要な Docker ラベルが CloudWatch エージェントで構成されていない可能性があります。ECS タスク定義 ARN 正規表現ベースのサービス検出の場合、CloudWatch エージェントの regex 設定がアプリケーションのタスク定義と一致していないことがあります。
+ CloudWatch エージェントの ECS タスクロールに、ECS タスクのメタデータを取得するアクセス許可がない可能性があります。CloudWatch エージェントに次の読み取り専用アクセス許可が付与されていることを確認します。
+ `ec2:DescribeInstances`
+ `ecs:ListTasks`
+ `ecs:DescribeContainerInstances`
+ `ecs:DescribeTasks`
+ `ecs:DescribeTaskDefinition`
**ステップ 3: ネットワーク接続と ECS タスクのロールポリシーを確認する**
`Exporter_DiscoveredTargetCount` の値が Prometheus ターゲットが検出されたことを示しているにもかかわらず、ターゲット CloudWatch Logs ロググループに送信されるログイベントがない場合は、次のいずれかが原因で発生している可能性があります。
+ CloudWatch エージェントが Prometheus ターゲットポートに接続できない可能性があります。CloudWatch エージェントの背後にあるセキュリティグループ設定を確認します。プライベート IP は、CloudWatch エージェントが Prometheus エクスポーターポートに接続できるようにする必要があります。
+ CloudWatch エージェントの ECS タスクロールに **CloudWatchAgentServerPolicy** マネージドポリシーがない可能性があります。Prometheus メトリクスをログイベントとして送信できるようにするには、CloudWatch エージェントの ECS タスクロールにこのポリシーが必要です。サンプル CloudFormation テンプレートを使用して IAM ロールを自動的に作成した場合、ECS タスクロールと ECS 実行ロールの両方に、Prometheus モニターリングを実行するための最小権限が付与されます。
# Amazon EKS および Kubernetes クラスターでの Prometheus メトリクスのトラブルシューティング
このセクションでは、Amazon EKS および Kubernetes クラスターでの Prometheus メトリクス設定のトラブルシューティングに役立つ情報を提供します。
## Amazon EKS の一般的なトラブルシューティングステップ
CloudWatch エージェントが実行中であることを確認するには、次のコマンドを使用します。
```
kubectl get pod -n amazon-cloudwatch
```
出力には、`cwagent-prometheus-id` 列の `NAME` と、`Running` の `STATUS column.` の行を含める必要があります。
実行中のポッドの詳細を表示するには、次のコマンドを入力します。*pod-name* は、`cw-agent-prometheus` で始まる名前を持つポッドの完全名に置き換えます。
```
kubectl describe pod pod-name -n amazon-cloudwatch
```
CloudWatch Container Insights がインストールされている場合は、CloudWatch Logs Insights を使用して、Prometheus メトリクスを収集する CloudWatch エージェントからログをクエリできます。
**アプリケーションログをクエリするには**
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. ナビゲーションペインで、[**CloudWatch Logs Insights**] を選択します。
1. アプリケーションログのロググループ **/aws/containerinsights/*cluster-name*/application** を選択します。
1. 検索クエリ式を次のクエリに置き換え、[**クエリの実行**] を選択します。
```
fields ispresent(kubernetes.pod_name) as haskubernetes_pod_name, stream, kubernetes.pod_name, log |
filter haskubernetes_pod_name and kubernetes.pod_name like /cwagent-prometheus
```
また、Prometheus メトリクスとメタデータが CloudWatch Logs イベントとして取り込まれていることを確認できます。
**Prometheus のデータが取り込まれていることを確認するには**
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. ナビゲーションペインで、[**CloudWatch Logs Insights**] を選択します。
1. [**/aws/containerinsights/*cluster-name*/prometheus**] を選択します。
1. 検索クエリ式を次のクエリに置き換え、[**クエリの実行**] を選択します。
```
fields @timestamp, @message | sort @timestamp desc | limit 20
```
## 削除された Prometheus メトリクスのログ記録
このリリースでは、ヒストグラムタイプの Prometheus メトリクスは収集されません。CloudWatch エージェントを使用して、Prometheus メトリクスがヒストグラムメトリクスであるために削除されているかどうかを確認できます。また、ヒストグラムメトリクスであるために、削除されて CloudWatch に送信されない最初の 500 個の Prometheus メトリクスのリストを記録することもできます。
メトリクスが削除されているかどうかを確認するには、次のコマンドを入力します。
```
kubectl logs -l "app=cwagent-prometheus" -n amazon-cloudwatch --tail=-1
```
メトリクスが削除されている場合は、`/opt/aws/amazon-cloudwatch-agent/logs/amazon-cloudwatch-agent.log` ファイルに次の行が表示されます。
```
I! Drop Prometheus metrics with unsupported types. Only Gauge, Counter and Summary are supported.
I! Please enable CWAgent debug mode to view the first 500 dropped metrics
```
これらの行が表示されている場合に、どのメトリクスが削除されているかを確認するには、次のステップを実行します。
**削除された Prometheus メトリクスのリストを記録するには**
1. `prometheus-eks.yaml` または `prometheus-k8s.yaml` ファイルに次の太字行を追加して、CloudWatch エージェントをデバッグモードに変更し、ファイルを保存します。
```
{
"agent": {
"debug": true
},
```
ファイルのこのセクションは、次のようになります。
```
cwagentconfig.json: |
{
"agent": {
"debug": true
},
"logs": {
"metrics_collected": {
```
1. 次のコマンドを入力して、CloudWatch エージェントを再インストールしてデバッグモードを有効にします。
```
kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch
kubectl apply -f prometheus.yaml
```
削除されたメトリクスは、CloudWatch エージェントポッドに記録されます。
1. CloudWatch エージェントポッドからログを取得するには、次のコマンドを入力します。
```
kubectl logs -l "app=cwagent-prometheus" -n amazon-cloudwatch --tail=-1
```
または、Container Insights Fluentd ログ記録がインストールされている場合、ログは CloudWatch Logs ロググループ **/aws/containerinsights/*cluster\$1name*/application** にも保存されます。
これらのログをクエリするには、「[Amazon EKS の一般的なトラブルシューティングステップ](#ContainerInsights-Prometheus-troubleshooting-general)」のアプリケーションログをクエリするステップに従います。
## Prometheus メトリクスが CloudWatch Logs ログイベントとして取り込まれる場所
CloudWatch エージェントは、Prometheus スクレイプジョブ設定ごとにログストリームを作成します。例えば、`prometheus-eks.yaml` および `prometheus-k8s.yaml` ファイルでは、`job_name: 'kubernetes-pod-appmesh-envoy'` 行が App Mesh メトリクスをスクレイプします。Prometheus ターゲットは `kubernetes-pod-appmesh-envoy` と定義されます。したがって、すべての App Mesh Prometheus メトリクスは、**/aws/containerinsights/cluster-name/Prometheus** という名前のロググループの下のログストリーム **kubernetes-pod-appmesh-envoy** に CloudWatch Logs イベントとして取り込まれます。
## CloudWatch メトリクスに Amazon EKS または Kubernetes Prometheus メトリクスが表示されない
まず、Prometheus メトリクスがロググループ **/aws/containerinsights/cluster-name/Prometheus** にログイベントとして取り込まれることを確認します。「[Prometheus メトリクスが CloudWatch Logs ログイベントとして取り込まれる場所](#ContainerInsights-Prometheus-troubleshooting-metrics_ingested)」の情報を使用して、ターゲットログストリームを確認します。ログストリームが作成されない場合、またはログストリームに新しいログイベントがない場合は、次の点を確認します。
+ Prometheus メトリクスエクスポーターのエンドポイントが正しく設定されていることを確認します。
+ CloudWatch エージェント YAML ファイルの `config map: cwagent-prometheus` セクションにある Prometheus スクレイピング設定が正しいことを確認します。この設定は、Prometheus 設定ファイルと同じになります。詳細については、Prometheus ドキュメントの「[](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config)」を参照してください。
Prometheus メトリクスがログイベントとして正しく取り込まれる場合は、埋め込みメトリクス形式設定がログイベントに追加され、CloudWatch メトリクスを生成することを確認します。
```
"CloudWatchMetrics":[
{
"Metrics":[
{
"Name":"envoy_http_downstream_cx_destroy_remote_active_rq"
}
],
"Dimensions":[
[
"ClusterName",
"Namespace"
]
],
"Namespace":"ContainerInsights/Prometheus"
}
],
```
埋め込みメトリックフォーマットの詳細については、「[仕様: 埋め込みメトリクスフォーマット](CloudWatch_Embedded_Metric_Format_Specification.md)」を参照してください。
ログイベントにメトリクス形式が埋め込まれていない場合は、CloudWatch エージェントインストール YAML ファイルの `config map: prometheus-cwagentconfig` セクションで、`metric_declaration` セクションが正しく設定されていることを確認してください。(詳細については、[新しい Prometheus スクレイピングターゲットを追加するためのチュートリアル: Prometheus API サーバーメトリクス](ContainerInsights-Prometheus-Setup-configure.md#ContainerInsights-Prometheus-Setup-new-exporters) を参照してください)。