

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Démarrez avec le serveur Amazon ECS MCP

Ce guide explique les étapes à suivre pour configurer et utiliser le serveur Amazon ECS MCP avec vos assistants de code IA. Vous allez apprendre à configurer votre environnement, à vous connecter au serveur et à commencer à gérer vos clusters Amazon ECS via des interactions en langage naturel.

**Note**  
Le serveur Amazon ECS MCP est en version préliminaire et est sujet à modification.

## Conditions préalables
<a name="ecs-mcp-prerequisites"></a>

Avant de commencer, assurez-vous de disposer des éléments suivants :
+ [Création d'un AWS compte avec accès à Amazon ECS ](https://aws.amazon.com/resources/create-account/)
+ [Installé et configuré le AWS CLI avec des informations d'identification ](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
+ [Python 3.10\+ installé ](https://www.python.org/)
+ [UV installé ](https://docs.astral.sh/uv/getting-started/installation/)

## Configuration
<a name="ecs-mcp-setup"></a>

### Vérifiez les conditions préalables
<a name="ecs-mcp-verify-prerequisites"></a>

Vérifiez que votre version de Python est 3.10 ou supérieure

```
python3 --version
```

Vérifiez l'installation UV

```
uv --version
```

Vérifier la AWS CLI configuration

```
aws configure list
```

### Définir des autorisations IAM
<a name="ecs-mcp-iam-permissions"></a>

Vous aurez besoin des [ autorisations ](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) IAM pour envoyer des requêtes en lecture seule aux AWS services et interagir avec le serveur MCP. Vous pouvez soit tirer parti des politiques [AWS gérées](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html), soit utiliser une seule politique personnalisée pour un contrôle plus précis.

**Option 1 : politique gérée et personnalisée combinée **

1. Joignez la politique AWS gérée ** ReadOnlyAccess ** pour un accès en lecture seule à tous les services AWS 

1. Créez et joignez une politique personnalisée supplémentaire pour les autorisations MCP (voir les autorisations MCP suivantes au format JSON)

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "MCPServerAccess",
      "Effect": "Allow",
      "Action": [
        "ecs-mcp:InvokeReadOnlyTools",
        "ecs-mcp:UseMcp"
      ],
      "Resource": "*"
    }
  ]
}
```

**Option 2 : politique personnalisée unique (contrôle le plus granulaire) **

Vous pouvez également créer et joindre une seule politique JSON personnalisée qui inclut à la fois les autorisations de AWS service et les autorisations MCP :

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "MCPServerAccess",
      "Effect": "Allow",
      "Action": [
        "ecs-mcp:InvokeReadOnlyTools",
        "ecs-mcp:UseMcp"
      ],
      "Resource": "*"
    },
    {
      "Sid": "ECSReadOnlyAccess",
      "Effect": "Allow",
      "Action": [
        "ecs:ListAccountSettings",
        "ecs:ListClusters",
        "ecs:ListContainerInstances",
        "ecs:ListTaskDefinitions",
        "ecs:ListServices",
        "ecs:ListServiceDeployments",
        "ecs:ListTasks",
        "ecs:DescribeClusters",
        "ecs:DescribeCapacityProviders",
        "ecs:DescribeContainerInstances",
        "ecs:DescribeTaskDefinition",
        "ecs:DescribeServices",
        "ecs:DescribeServiceDeployments",
        "ecs:DescribeServiceRevisions",
        "ecs:DescribeTaskSets",
        "ecs:DescribeTasks"
      ],
      "Resource": "*"
    },
    {
      "Sid": "CloudWatchLogsReadOnlyAccess",
      "Effect": "Allow",
      "Action": [
        "logs:DescribeLogGroups",
        "logs:DescribeLogStreams",
        "logs:GetLogEvents",
        "logs:FilterLogEvents"
      ],
      "Resource": "*"
    },
    {
      "Sid": "ELBReadOnlyAccess",
      "Effect": "Allow",
      "Action": [
        "elasticloadbalancing:DescribeLoadBalancers",
        "elasticloadbalancing:DescribeTargetGroups",
        "elasticloadbalancing:DescribeListeners"
      ],
      "Resource": "*"
    },
    {
      "Sid": "EC2ReadOnlyAccess",
      "Effect": "Allow",
      "Action": [
        "ec2:DescribeVpcs",
        "ec2:DescribeSubnets",
        "ec2:DescribeSecurityGroups",
        "ec2:DescribeRouteTables",
        "ec2:DescribeNetworkInterfaces"
      ],
      "Resource": "*"
    },
    {
      "Sid": "ECRReadOnlyAccess",
      "Effect": "Allow",
      "Action": [
        "ecr:DescribeRepositories",
        "ecr:DescribeImages"
      ],
      "Resource": "*"
    },
    {
      "Sid": "IAMReadOnlyAccessForSecurityAnalysis",
      "Effect": "Allow",
      "Action": [
        "iam:GetRole",
        "iam:ListAttachedRolePolicies",
        "iam:GetPolicy",
        "iam:GetPolicyVersion",
        "iam:ListRolePolicies",
        "iam:GetRolePolicy"
      ],
      "Resource": "*"
    }
  ]
}
```

### Choisissez et configurez un assistant IA
<a name="ecs-mcp-configure-assistant"></a>

Installez des assistants MCP-compatible IA ou tout autre MCP-compatible outil. Par exemple, vous pouvez utiliser [ Kiro](https://kiro.dev/), [ Cline](https://cline.bot/), [ Cursor ](https://cursor.com/) ou [ Claude Code. ](https://www.claude.com/product/claude-code) Configurez ensuite votre assistant de code AI pour qu'il utilise le serveur Amazon ECS MCP via MCP Proxy for AWS, qui est requis pour un accès sécurisé et authentifié au serveur Amazon ECS MCP. Le proxy agit comme un pont côté client et gère l'authentification AWS SIGv4 à l'aide de vos informations d'identification locales. AWS L'exemple ci-dessous utilise l'interface de ligne de commande Kiro. Cliquez [ sur ce lien ](https://kiro.dev/docs/cli/mcp/) pour en savoir plus sur la configuration de MCP dans Kiro.

#### Localisez le fichier de configuration MCP
<a name="ecs-mcp-kiro-config-file"></a>
+ **macOS/Linux:**

  ```
  ~/.kiro/settings/mcp.json
  ```
+ **Windows:**

  ```
  %USERPROFILE%\.kiro\settings\mcp.json
  ```

Créez le fichier de configuration s'il n'existe pas.

#### Ajouter une configuration de serveur MCP
<a name="ecs-mcp-kiro-add-config"></a>

Assurez-vous de remplacer l'espace réservé region (`{region}`) par la région de votre choix (par exemple,`us-west-2`). Reportez-vous au [Conteneurs Linux sur AWS Fargate](AWS_Fargate-Regions.md#linux-regions) pour obtenir la liste complète des régions. Veillez également à remplacer l'`{profile}`espace réservé par le nom de votre [AWS CLI profil](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-quickstart.html), par ex. `default`

**Pour Mac/Linux : **

```
{
  "mcpServers": {
    "ecs-mcp": {
      "disabled": false,
      "type": "stdio",
      "command": "uvx",
      "args": [
        "mcp-proxy-for-aws@latest",
        "https://ecs-mcp.{region}.api.aws/mcp",
        "--service",
        "ecs-mcp",
        "--profile",
        "{profile}",
        "--region",
        "{region}"
      ]
    }
  }
}
```

**Pour Windows:**

```
{
  "mcpServers": {
    "ecs-mcp": {
      "disabled": false,
      "type": "stdio",
      "command": "uvx",
      "args": [
        "--from",
        "mcp-proxy-for-aws@latest",
        "mcp-proxy-for-aws.exe",
        "https://ecs-mcp.{region}.api.aws/mcp",
        "--service",
        "ecs-mcp",
        "--profile",
        "{profile}",
        "--region",
        "{region}"
      ]
    }
  }
}
```

#### Vérifier la configuration
<a name="ecs-mcp-kiro-verify"></a>

Redémarrez Kiro CLI`kiro-cli`, vérifiez que le serveur MCP est chargé et vérifiez `/mcp` les outils disponibles. `/tools`

#### Vérification de votre configuration
<a name="ecs-mcp-verify-setup"></a>

**Connexion de test **

Posez une question simple à votre assistant IA pour vérifier la connexion :

```
List all ECS clusters in my AWS account
```

Vous devriez voir la liste de vos clusters Amazon ECS.

#### Discutez avec votre assistant IA qui utilise le serveur Amazon ECS MCP
<a name="ecs-mcp-first-tasks"></a>

**Exemple 1 : Surveiller les déploiements **

```
Check deployment status for my web-service in production-cluster
Show me the ALB URL for my deployed service
Get service events for the last hour
```

**Exemple 2 : Étudier l'état du conteneur **

```
Show me all tasks that failed in the last 2 hours
Why are my containers failing health checks?
Display container logs for my api-service
```

**Exemple 3 : résolution des problèmes **

```
Analyze task failures in my production cluster
Check for image pull errors in the last 30 minutes
Why is my task definition stuck in DELETE_IN_PROGRESS state?
```

**Exemple 4 : Inspecter les configurations **

```
Show me the network configuration for my web-service
What security groups are attached to my service?
List all VPC and subnet details for my ECS service
```

**Exemple 5 : évaluer la posture de sécurité **

```
Are there any security issues with my production cluster?
Analyze IAM roles and policies for my web-service
Check for overly permissive security groups in my ECS cluster
```

## Configurations courantes et meilleures pratiques
<a name="ecs-mcp-common-configs"></a>

### Plusieurs AWS profils
<a name="ecs-mcp-multiple-profiles"></a>

Si vous travaillez avec plusieurs AWS comptes, créez des configurations de serveur MCP distinctes.

**Pour Mac/Linux : **

```
{
  "mcpServers": {
    "ecs-mcp-prod": {
      "disabled": false,
      "type": "stdio",
      "command": "uvx",
      "args": [
        "mcp-proxy-for-aws@latest",
        "https://ecs-mcp.{region}.api.aws/mcp",
        "--service",
        "ecs-mcp",
        "--profile",
        "production",
        "--region",
        "us-west-2"
      ]
    },
    "ecs-mcp-dev": {
      "disabled": false,
      "type": "stdio",
      "command": "uvx",
      "args": [
        "mcp-proxy-for-aws@latest",
        "https://ecs-mcp.{region}.api.aws/mcp",
        "--service",
        "ecs-mcp",
        "--profile",
        "development",
        "--region",
        "us-east-1"
      ]
    }
  }
}
```

### Bonnes pratiques de sécurité
<a name="ecs-mcp-security-best-practices"></a>

Ne transmettez pas de secrets ou d'informations sensibles via les mécanismes de saisie autorisés :
+ N'incluez pas de secrets ou d'informations d'identification dans les fichiers de configuration
+ Ne transmettez pas d'informations sensibles directement dans les instructions au modèle
+ N'incluez pas de secrets dans les définitions de tâches ou les configurations de service
+ Évitez de consigner des informations sensibles dans les journaux des applications
+ Utilisez ou Parameter Store pour stocker des informations sensibles

## Configurations des outils
<a name="ecs-mcp-next-steps"></a>

Pour une liste complète des outils et des configurations, consultez[Configurations de l'outil serveur Amazon ECS MCP](ecs-mcp-tool-configurations.md).