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.
# Exemples d'App Mesh utilisant AWS CLI
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS Command Line Interface aide de l'App Mesh.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Actions](#actions)
## Actions
### `create-mesh`
L'exemple de code suivant montre comment utiliser`create-mesh`.
**AWS CLI**
**Exemple 1 : pour créer un nouveau maillage de services**
L’exemple `create-mesh` suivant crée un maillage de services.
```
aws appmesh create-mesh \
--mesh-name app1
```
Sortie :
```
{
"mesh":{
"meshName":"app1",
"metadata":{
"arn":"arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
"createdAt":1563809909.282,
"lastUpdatedAt":1563809909.282,
"uid":"a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version":1
},
"spec":{},
"status":{
"status":"ACTIVE"
}
}
}
```
**Exemple 2 : pour créer un nouveau maillage de services avec plusieurs balises**
L’exemple `create-mesh` suivant crée un maillage de services avec plusieurs balises.
```
aws appmesh create-mesh \
--mesh-name app2 \
--tags key=key1,value=value1 key=key2,value=value2 key=key3,value=value3
```
Sortie :
```
{
"mesh":{
"meshName":"app2",
"metadata":{
"arn":"arn:aws:appmesh:us-east-1:123456789012:mesh/app2",
"createdAt":1563822121.877,
"lastUpdatedAt":1563822121.877,
"uid":"a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version":1
},
"spec":{},
"status":{
"status":"ACTIVE"
}
}
}
```
Pour plus d’informations, consultez [Maillage de services](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [CreateMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-mesh.html)la section *Référence des AWS CLI commandes*.
### `create-route`
L'exemple de code suivant montre comment utiliser`create-route`.
**AWS CLI**
**Pour créer une route gRPC**
L’exemple `create-route` suivant utilise un fichier d’entrée JSON pour créer une route gRPC. Le trafic GRPC dont les métadonnées commencent par 123 est acheminé vers un nœud virtuel nommé serviceBgrpc. En cas d’échec gRPC, HTTP ou TCP lors de la tentative de communication avec la cible de la route, la route est réessayée trois fois. Il y a un délai de 15 secondes entre chaque nouvelle tentative.
```
aws appmesh create-route \
--cli-input-json file://create-route-grpc.json
```
Contenu de `create-route-grpc.json` :
```
{
"meshName" : "apps",
"routeName" : "grpcRoute",
"spec" : {
"grpcRoute" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceBgrpc",
"weight" : 100
}
]
},
"match" : {
"metadata" : [
{
"invert" : false,
"match" : {
"prefix" : "123"
},
"name" : "myMetadata"
}
],
"methodName" : "GetColor",
"serviceName" : "com.amazonaws.services.ColorService"
},
"retryPolicy" : {
"grpcRetryEvents" : [ "deadline-exceeded" ],
"httpRetryEvents" : [ "server-error", "gateway-error" ],
"maxRetries" : 3,
"perRetryTimeout" : {
"unit" : "s",
"value" : 15
},
"tcpRetryEvents" : [ "connection-error" ]
}
},
"priority" : 100
},
"virtualRouterName" : "serviceBgrpc"
}
```
Sortie :
```
{
"route": {
"meshName": "apps",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:123456789012:mesh/apps/virtualRouter/serviceBgrpc/route/grpcRoute",
"createdAt": 1572010806.008,
"lastUpdatedAt": 1572010806.008,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"routeName": "grpcRoute",
"spec": {
"grpcRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "serviceBgrpc",
"weight": 100
}
]
},
"match": {
"metadata": [
{
"invert": false,
"match": {
"prefix": "123"
},
"name": "mymetadata"
}
],
"methodName": "GetColor",
"serviceName": "com.amazonaws.services.ColorService"
},
"retryPolicy": {
"grpcRetryEvents": [
"deadline-exceeded"
],
"httpRetryEvents": [
"server-error",
"gateway-error"
],
"maxRetries": 3,
"perRetryTimeout": {
"unit": "s",
"value": 15
},
"tcpRetryEvents": [
"connection-error"
]
}
},
"priority": 100
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "serviceBgrpc"
}
}
```
**Pour créer une route HTTP ou HTTP/2**
L’exemple `create-route` suivant utilise un fichier d’entrée JSON pour créer une route HTTP/2. Pour créer une route HTTP, remplacez http2Route par httpRoute selon les spécifications. Tout le trafic HTTP/2 adressé à un préfixe d’URL dont la valeur d’en-tête commence par 123 est acheminé vers un nœud virtuel nommé serviceBhttp2. En cas d’échec HTTP ou TCP lors de la tentative de communication avec la cible de la route, la route est réessayée trois fois. Il y a un délai de 15 secondes entre chaque nouvelle tentative.
```
aws appmesh create-route \
--cli-input-json file://create-route-http2.json
```
Contenu de `create-route-http2.json` :
```
{
"meshName": "apps",
"routeName": "http2Route",
"spec": {
"http2Route": {
"action": {
"weightedTargets": [
{
"virtualNode": "serviceBhttp2",
"weight": 100
}
]
},
"match": {
"headers": [
{
"invert": false,
"match": {
"prefix": "123"
},
"name": "clientRequestId"
}
],
"method": "POST",
"prefix": "/",
"scheme": "http"
},
"retryPolicy": {
"httpRetryEvents": [
"server-error",
"gateway-error"
],
"maxRetries": 3,
"perRetryTimeout": {
"unit": "s",
"value": 15
},
"tcpRetryEvents": [
"connection-error"
]
}
},
"priority": 200
},
"virtualRouterName": "serviceBhttp2"
}
```
Sortie :
```
{
"route": {
"meshName": "apps",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:123456789012:mesh/apps/virtualRouter/serviceBhttp2/route/http2Route",
"createdAt": 1572011008.352,
"lastUpdatedAt": 1572011008.352,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"routeName": "http2Route",
"spec": {
"http2Route": {
"action": {
"weightedTargets": [
{
"virtualNode": "serviceBhttp2",
"weight": 100
}
]
},
"match": {
"headers": [
{
"invert": false,
"match": {
"prefix": "123"
},
"name": "clientRequestId"
}
],
"method": "POST",
"prefix": "/",
"scheme": "http"
},
"retryPolicy": {
"httpRetryEvents": [
"server-error",
"gateway-error"
],
"maxRetries": 3,
"perRetryTimeout": {
"unit": "s",
"value": 15
},
"tcpRetryEvents": [
"connection-error"
]
}
},
"priority": 200
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "serviceBhttp2"
}
}
```
**Pour créer une route TCP**
L’exemple `create-route` suivant utilise un fichier d’entrée JSON pour créer une route TCP. 75 % du trafic est acheminé vers un nœud virtuel nommé serviceBtcp et 25 % du trafic est acheminé vers un nœud virtuel nommé serviceBv2tcp. La spécification de différentes pondérations pour différentes cibles est un moyen efficace de déployer une nouvelle version d’une application. Vous pouvez ajuster les pondérations de manière à ce que 100 % du trafic soit finalement acheminé vers une cible dotée de la nouvelle version d’une application.
```
aws appmesh create-route \
--cli-input-json file://create-route-tcp.json
```
Contenu du create-route-tcp fichier .json :
```
{
"meshName": "apps",
"routeName": "tcpRoute",
"spec": {
"priority": 300,
"tcpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "serviceBtcp",
"weight": 75
},
{
"virtualNode": "serviceBv2tcp",
"weight": 25
}
]
}
}
},
"virtualRouterName": "serviceBtcp"
}
```
Sortie :
```
{
"route": {
"meshName": "apps",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:123456789012:mesh/apps/virtualRouter/serviceBtcp/route/tcpRoute",
"createdAt": 1572011436.26,
"lastUpdatedAt": 1572011436.26,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"routeName": "tcpRoute",
"spec": {
"priority": 300,
"tcpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "serviceBtcp",
"weight": 75
},
{
"virtualNode": "serviceBv2tcp",
"weight": 25
}
]
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "serviceBtcp"
}
}
```
Pour plus d’informations, consultez [Routes](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [CreateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-route.html)la section *Référence des AWS CLI commandes*.
### `create-virtual-gateway`
L'exemple de code suivant montre comment utiliser`create-virtual-gateway`.
**AWS CLI**
**Pour créer une nouvelle passerelle virtuelle**
L’exemple `create-virtual-gateway` suivant utilise un fichier d’entrée JSON pour créer une passerelle virtuelle avec un écouteur pour HTTP à l’aide du port 9080.
```
aws appmesh create-virtual-gateway \
--mesh-name meshName \
--virtual-gateway-name virtualGatewayName \
--cli-input-json file://create-virtual-gateway.json
```
Contenu de `create-virtual-gateway.json` :
```
{
"spec": {
"listeners": [
{
"portMapping": {
"port": 9080,
"protocol": "http"
}
}
]
}
}
```
Sortie :
```
{
"virtualGateway": {
"meshName": "meshName",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:123456789012:mesh/meshName/virtualGateway/virtualGatewayName",
"createdAt": "2022-04-06T10:42:42.015000-05:00",
"lastUpdatedAt": "2022-04-06T10:42:42.015000-05:00",
"meshOwner": "123456789012",
"resourceOwner": "123456789012",
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 9080,
"protocol": "http"
}
}
]
},
"status": {
"status": "ACTIVE"
},
"virtualGatewayName": "virtualGatewayName"
}
}
```
Pour plus d’informations, consultez [Passerelles virtuelles](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_gateways.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [CreateVirtualGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-gateway.html)la section *Référence des AWS CLI commandes*.
### `create-virtual-node`
L'exemple de code suivant montre comment utiliser`create-virtual-node`.
**AWS CLI**
**Exemple 1 : pour créer un nouveau nœud virtuel qui utilise le DNS pour la découverte**
L’exemple `create-virtual-node` suivant utilise un fichier d’entrée JSON pour créer un nœud virtuel qui utilise DNS pour la découverte de service.
```
aws appmesh create-virtual-node \
--cli-input-json file://create-virtual-node-dns.json
```
Contenu de `create-virtual-node-dns.json` :
```
{
"meshName": "app1",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv1.svc.cluster.local"
}
}
},
"virtualNodeName": "vnServiceBv1"
}
```
Sortie :
```
{
"virtualNode": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceBv1",
"createdAt": 1563810019.874,
"lastUpdatedAt": 1563810019.874,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv1.svc.cluster.local"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualNodeName": "vnServiceBv1"
}
}
```
**Exemple 2 : pour créer un nouveau nœud virtuel qui utilise AWS Cloud Map pour la découverte**
L'`create-virtual-node`exemple suivant utilise un fichier d'entrée JSON pour créer un nœud virtuel qui utilise AWS Cloud Map pour la découverte de services.
```
aws appmesh create-virtual-node \
--cli-input-json file://create-virtual-node-cloud-map.json
```
Contenu de `create-virtual-node-cloud-map.json` :
```
{
"meshName": "app1",
"spec": {
"backends": [
{
"virtualService": {
"virtualServiceName": "serviceA.svc.cluster.local"
}
}
],
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"awsCloudMap": {
"attributes": [
{
"key": "Environment",
"value": "Testing"
}
],
"namespaceName": "namespace1",
"serviceName": "serviceA"
}
}
},
"virtualNodeName": "vnServiceA"
}
```
Sortie :
```
{
"virtualNode": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceA",
"createdAt": 1563810859.465,
"lastUpdatedAt": 1563810859.465,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"backends": [
{
"virtualService": {
"virtualServiceName": "serviceA.svc.cluster.local"
}
}
],
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"awsCloudMap": {
"attributes": [
{
"key": "Environment",
"value": "Testing"
}
],
"namespaceName": "namespace1",
"serviceName": "serviceA"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualNodeName": "vnServiceA"
}
}
```
Pour plus d’informations, consultez [Nœud virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [CreateVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-node.html)la section *Référence des AWS CLI commandes*.
### `create-virtual-router`
L'exemple de code suivant montre comment utiliser`create-virtual-router`.
**AWS CLI**
**Pour créer un nouveau routeur virtuel**
L’exemple `create-virtual-router` suivant utilise un fichier d’entrée JSON pour créer un routeur virtuel avec un écouteur pour HTTP à l’aide du port 80.
```
aws appmesh create-virtual-router \
--cli-input-json file://create-virtual-router.json
```
Contenu de `create-virtual-router.json` :
```
{
"meshName": "app1",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
]
},
"virtualRouterName": "vrServiceB"
}
```
Sortie :
```
{
"virtualRouter": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
"createdAt": 1563810546.59,
"lastUpdatedAt": 1563810546.59,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
]
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "vrServiceB"
}
}
```
Pour plus d’informations, consultez [Routeurs virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [CreateVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-router.html)la section *Référence des AWS CLI commandes*.
### `create-virtual-service`
L'exemple de code suivant montre comment utiliser`create-virtual-service`.
**AWS CLI**
**Exemple 1 : pour créer un nouveau service virtuel avec un fournisseur de nœuds virtuels**
L’exemple `create-virtual-service` suivant utilise un fichier d’entrée JSON pour créer un service virtuel avec un fournisseur de nœuds virtuels.
```
aws appmesh create-virtual-service \
--cli-input-json file://create-virtual-service-virtual-node.json
```
Contenu de `create-virtual-service-virtual-node.json` :
```
{
"meshName": "app1",
"spec": {
"provider": {
"virtualNode": {
"virtualNodeName": "vnServiceA"
}
}
},
"virtualServiceName": "serviceA.svc.cluster.local"
}
```
Sortie :
```
{
"virtualService": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceA.svc.cluster.local",
"createdAt": 1563810859.474,
"lastUpdatedAt": 1563810967.179,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"spec": {
"provider": {
"virtualNode": {
"virtualNodeName": "vnServiceA"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualServiceName": "serviceA.svc.cluster.local"
}
}
```
Pour plus d’informations, consultez [Nœud virtuel](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
**Exemple 2 : pour créer un nouveau service virtuel avec un fournisseur de routeur virtuel**
L’exemple `create-virtual-service` suivant utilise un fichier d’entrée JSON pour créer un service virtuel avec un fournisseur de routeur virtuel.
```
aws appmesh create-virtual-service \
--cli-input-json file://create-virtual-service-virtual-router.json
```
Contenu de `create-virtual-service-virtual-router.json` :
```
{
"meshName": "app1",
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "vrServiceB"
}
}
},
"virtualServiceName": "serviceB.svc.cluster.local"
}
```
Sortie :
```
{
"virtualService": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceB.svc.cluster.local",
"createdAt": 1563908363.999,
"lastUpdatedAt": 1563908363.999,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "vrServiceB"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualServiceName": "serviceB.svc.cluster.local"
}
}
```
*Pour plus d'informations, consultez Virtual Services< https://docs.aws.amazon.com/app-mesh/ latest/userguide/virtual \$1services.html> dans le guide de l'utilisateur d'App Mesh AWS *
+ Pour plus de détails sur l'API, voir [CreateVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-service.html)la section *Référence des AWS CLI commandes*.
### `delete-mesh`
L'exemple de code suivant montre comment utiliser`delete-mesh`.
**AWS CLI**
**Pour supprimer un maillage de services**
L’exemple `delete-mesh` suivant supprime le maillage de services spécifié.
```
aws appmesh delete-mesh \
--mesh-name app1
```
Sortie :
```
{
"mesh": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
"createdAt": 1563809909.282,
"lastUpdatedAt": 1563824981.248,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"spec": {
"egressFilter": {
"type": "ALLOW_ALL"
}
},
"status": {
"status": "DELETED"
}
}
}
```
Pour plus d’informations, consultez [Maillage de services](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [DeleteMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-mesh.html)la section *Référence des AWS CLI commandes*.
### `delete-route`
L'exemple de code suivant montre comment utiliser`delete-route`.
**AWS CLI**
**Pour supprimer une route**
L’exemple `delete-route` suivant supprime la route spécifiée.
```
aws appmesh delete-route \
--mesh-name app1 \
--virtual-router-name vrServiceB \
--route-name toVnServiceB-weighted
```
Sortie :
```
{
"route": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB/route/toVnServiceB-weighted",
"createdAt": 1563811384.015,
"lastUpdatedAt": 1563823915.936,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 3
},
"routeName": "toVnServiceB-weighted",
"spec": {
"httpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "vnServiceBv1",
"weight": 80
},
{
"virtualNode": "vnServiceBv2",
"weight": 20
}
]
},
"match": {
"prefix": "/"
}
}
},
"status": {
"status": "DELETED"
},
"virtualRouterName": "vrServiceB"
}
}
```
Pour plus d’informations, consultez [Routes](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [DeleteRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-route.html)la section *Référence des AWS CLI commandes*.
### `delete-virtual-node`
L'exemple de code suivant montre comment utiliser`delete-virtual-node`.
**AWS CLI**
**Pour supprimer un nœud virtuel**
L’exemple `delete-virtual-node` suivant supprime le nœud virtuel spécifié.
```
aws appmesh delete-virtual-node \
--mesh-name app1 \
--virtual-node-name vnServiceBv2
```
Sortie :
```
{
"virtualNode": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceBv2",
"createdAt": 1563810117.297,
"lastUpdatedAt": 1563824700.678,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"spec": {
"backends": [],
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv2.svc.cluster.local"
}
}
},
"status": {
"status": "DELETED"
},
"virtualNodeName": "vnServiceBv2"
}
}
```
Pour plus d’informations, consultez [Nœud virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [DeleteVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-virtual-node.html)la section *Référence des AWS CLI commandes*.
### `delete-virtual-router`
L'exemple de code suivant montre comment utiliser`delete-virtual-router`.
**AWS CLI**
**Pour supprimer un routeur virtuel**
L’exemple `delete-virtual-router` suivant supprime le routeur virtuel spécifié.
```
aws appmesh delete-virtual-router \
--mesh-name app1 \
--virtual-router-name vrServiceB
```
Sortie :
```
{
"virtualRouter": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
"createdAt": 1563810546.59,
"lastUpdatedAt": 1563824253.467,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 3
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
]
},
"status": {
"status": "DELETED"
},
"virtualRouterName": "vrServiceB"
}
}
```
Pour plus d’informations, consultez [Routeurs virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [DeleteVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-virtual-router.html)la section *Référence des AWS CLI commandes*.
### `delete-virtual-service`
L'exemple de code suivant montre comment utiliser`delete-virtual-service`.
**AWS CLI**
**Pour supprimer un service virtuel**
L’exemple `delete-virtual-service` suivant supprime le service virtuel spécifié.
```
aws appmesh delete-virtual-service \
--mesh-name app1 \
--virtual-service-name serviceB.svc.cluster.local
```
Sortie :
```
{
"virtualService": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceB.svc.cluster.local",
"createdAt": 1563908363.999,
"lastUpdatedAt": 1563913940.866,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 3
},
"spec": {},
"status": {
"status": "DELETED"
},
"virtualServiceName": "serviceB.svc.cluster.local"
}
}
```
Pour plus d’informations, consultez [Service virtuel](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [DeleteVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-virtual-service.html)la section *Référence des AWS CLI commandes*.
### `describe-mesh`
L'exemple de code suivant montre comment utiliser`describe-mesh`.
**AWS CLI**
**Pour décrire un maillage de services**
L’exemple `describe-mesh` suivant renvoie des informations sur le maillage de services spécifié.
```
aws appmesh describe-mesh \
--mesh-name app1
```
Sortie :
```
{
"mesh": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
"createdAt": 1563809909.282,
"lastUpdatedAt": 1563809909.282,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {},
"status": {
"status": "ACTIVE"
}
}
}
```
Pour plus d’informations, consultez [Maillage de services](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [DescribeMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-mesh.html)la section *Référence des AWS CLI commandes*.
### `describe-route`
L'exemple de code suivant montre comment utiliser`describe-route`.
**AWS CLI**
**Pour décrire une route**
L’exemple `describe-route` suivant renvoie des informations sur la route spécifiée.
```
aws appmesh describe-route \
--mesh-name app1 \
--virtual-router-name vrServiceB \
--route-name toVnServiceB-weighted
```
Sortie :
```
{
"route": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB/route/toVnServiceB-weighted",
"createdAt": 1563811384.015,
"lastUpdatedAt": 1563811384.015,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"routeName": "toVnServiceB-weighted",
"spec": {
"httpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "vnServiceBv1",
"weight": 90
},
{
"virtualNode": "vnServiceBv2",
"weight": 10
}
]
},
"match": {
"prefix": "/"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "vrServiceB"
}
}
```
Pour plus d’informations, consultez [Routes](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [DescribeRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-route.html)la section *Référence des AWS CLI commandes*.
### `describe-virtual-node`
L'exemple de code suivant montre comment utiliser`describe-virtual-node`.
**AWS CLI**
**Pour décrire un nœud virtuel**
L’exemple `describe-virtual-node` suivant renvoie des informations sur le nœud virtuel spécifié.
```
aws appmesh describe-virtual-node \
--mesh-name app1 \
--virtual-node-name vnServiceBv1
```
Sortie :
```
{
"virtualNode": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceBv1",
"createdAt": 1563810019.874,
"lastUpdatedAt": 1563810019.874,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"backends": [],
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv1.svc.cluster.local"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualNodeName": "vnServiceBv1"
}
}
```
Pour plus d’informations, consultez [Nœud virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [DescribeVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-virtual-node.html)la section *Référence des AWS CLI commandes*.
### `describe-virtual-router`
L'exemple de code suivant montre comment utiliser`describe-virtual-router`.
**AWS CLI**
**Pour décrire un routeur virtuel**
L’exemple `describe-virtual-router` suivant renvoie des informations sur le routeur virtuel spécifié.
```
aws appmesh describe-virtual-router \
--mesh-name app1 \
--virtual-router-name vrServiceB
```
Sortie :
```
{
"virtualRouter": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
"createdAt": 1563810546.59,
"lastUpdatedAt": 1563810546.59,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
]
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "vrServiceB"
}
}
```
Pour plus d’informations, consultez [Routeurs virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [DescribeVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-virtual-router.html)la section *Référence des AWS CLI commandes*.
### `describe-virtual-service`
L'exemple de code suivant montre comment utiliser`describe-virtual-service`.
**AWS CLI**
**Pour décrire un service virtuel**
L’exemple `describe-virtual-service` suivant renvoie des informations sur le service virtuel spécifié.
```
aws appmesh describe-virtual-service \
--mesh-name app1 \
--virtual-service-name serviceB.svc.cluster.local
```
Sortie :
```
{
"virtualService": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceB.svc.cluster.local",
"createdAt": 1563908363.999,
"lastUpdatedAt": 1563908363.999,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "vrServiceB"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualServiceName": "serviceB.svc.cluster.local"
}
}
```
Pour plus d’informations, consultez [Service virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [DescribeVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-virtual-service.html)la section *Référence des AWS CLI commandes*.
### `list-meshes`
L'exemple de code suivant montre comment utiliser`list-meshes`.
**AWS CLI**
**Pour répertorier les maillages de services**
L'`list-meshes`exemple suivant répertorie tous les maillages de service de la AWS région actuelle.
```
aws appmesh list-meshes
```
Sortie :
```
{
"meshes": [
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
"meshName": "app1"
}
]
}
```
Pour plus d’informations, consultez [Maillage de services](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [ListMeshes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-meshes.html)la section *Référence des AWS CLI commandes*.
### `list-routes`
L'exemple de code suivant montre comment utiliser`list-routes`.
**AWS CLI**
**Pour répertorier les routes**
L’exemple `list-routes` suivant répertorie toutes les routes pour le routeur virtuel spécifié.
```
aws appmesh list-routes \
--mesh-name app1 \
--virtual-router-name vrServiceB
```
Sortie :
```
{
"routes": [
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB/route/toVnServiceB",
"meshName": "app1",
"routeName": "toVnServiceB-weighted",
"virtualRouterName": "vrServiceB"
}
]
}
```
Pour plus d’informations, consultez [Routes](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [ListRoutes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-routes.html)la section *Référence des AWS CLI commandes*.
### `list-tags-for-resource`
L'exemple de code suivant montre comment utiliser`list-tags-for-resource`.
**AWS CLI**
**Pour répertorier les balises d’une ressource**
L’exemple `list-tags-for-resource` suivant répertorie toutes les balises attribuées à la ressource spécifiée.
```
aws appmesh list-tags-for-resource \
--resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1
```
Sortie :
```
{
"tags": [
{
"key": "key1",
"value": "value1"
},
{
"key": "key2",
"value": "value2"
},
{
"key": "key3",
"value": "value3"
}
]
}
```
+ Pour plus de détails sur l'API, voir [ListTagsForResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-tags-for-resource.html)la section *Référence des AWS CLI commandes*.
### `list-virtual-nodes`
L'exemple de code suivant montre comment utiliser`list-virtual-nodes`.
**AWS CLI**
**Pour répertorier les nœuds virtuels**
L’exemple `list-virtual-nodes` suivant répertorie tous les nœuds virtuels dans le maillage de services spécifié.
```
aws appmesh list-virtual-nodes \
--mesh-name app1
```
Sortie :
```
{
"virtualNodes": [
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceBv1",
"meshName": "app1",
"virtualNodeName": "vnServiceBv1"
},
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceBv2",
"meshName": "app1",
"virtualNodeName": "vnServiceBv2"
}
]
}
```
Pour plus d’informations, consultez [Nœud virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [ListVirtualNodes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-virtual-nodes.html)la section *Référence des AWS CLI commandes*.
### `list-virtual-routers`
L'exemple de code suivant montre comment utiliser`list-virtual-routers`.
**AWS CLI**
**Pour répertorier les routeurs virtuels**
L’exemple `list-virtual-routers` suivant répertorie tous les routeurs virtuels dans le maillage de services spécifié.
```
aws appmesh list-virtual-routers \
--mesh-name app1
```
Sortie :
```
{
"virtualRouters": [
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
"meshName": "app1",
"virtualRouterName": "vrServiceB"
}
]
}
```
Pour plus d’informations, consultez [Routeurs virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [ListVirtualRouters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-virtual-routers.html)la section *Référence des AWS CLI commandes*.
### `list-virtual-services`
L'exemple de code suivant montre comment utiliser`list-virtual-services`.
**AWS CLI**
**Pour répertorier les services virtuels**
L’exemple `list-virtual-services` suivant répertorie tous les services virtuels dans le maillage de services spécifié.
```
aws appmesh list-virtual-services \
--mesh-name app1
```
Sortie :
```
{
"virtualServices": [
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceA.svc.cluster.local",
"meshName": "app1",
"virtualServiceName": "serviceA.svc.cluster.local"
},
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceB.svc.cluster.local",
"meshName": "app1",
"virtualServiceName": "serviceB.svc.cluster.local"
}
]
}
```
Pour plus d’informations, consultez [Service virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [ListVirtualServices](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-virtual-services.html)la section *Référence des AWS CLI commandes*.
### `tag-resource`
L'exemple de code suivant montre comment utiliser`tag-resource`.
**AWS CLI**
**Pour baliser une ressource**
L’exemple `tag-resource` suivant ajoute la balise `key1` avec la valeur `value1` à la ressource spécifiée.
```
aws appmesh tag-resource \
--resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1 \
--tags key=key1,value=value1
```
Cette commande ne produit aucune sortie.
+ Pour plus de détails sur l'API, voir [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/tag-resource.html)la section *Référence des AWS CLI commandes*.
### `untag-resource`
L'exemple de code suivant montre comment utiliser`untag-resource`.
**AWS CLI**
**Pour supprimer les balises d’une ressource**
L’exemple `untag-resource` suivant supprime une balise avec la clé `key1` de la ressource spécifiée.
```
aws appmesh untag-resource \
--resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1 \
--tag-keys key1
```
Cette commande ne produit aucune sortie.
+ Pour plus de détails sur l'API, voir [UntagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/untag-resource.html)la section *Référence des AWS CLI commandes*.
### `update-mesh`
L'exemple de code suivant montre comment utiliser`update-mesh`.
**AWS CLI**
**Pour mettre à jour un maillage de services**
L’exemple `update-mesh` suivant utilise un fichier d’entrée JSON pour mettre à jour un maillage de services afin de permettre à tout le trafic sortant externe d’être transféré sans modification via le proxy Envoy.
```
aws appmesh update-mesh \
--cli-input-json file://update-mesh.json
```
Contenu de `update-mesh.json` :
```
{
"meshName": "app1",
"spec": {
"egressFilter": {
"type": "ALLOW_ALL"
}
}
}
```
Sortie :
```
{
"mesh": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
"createdAt": 1563809909.282,
"lastUpdatedAt": 1563812829.687,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"spec": {
"egressFilter": {
"type": "ALLOW_ALL"
}
},
"status": {
"status": "ACTIVE"
}
}
}
```
Pour plus d’informations, consultez [Maillage de services](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [UpdateMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-mesh.html)la section *Référence des AWS CLI commandes*.
### `update-route`
L'exemple de code suivant montre comment utiliser`update-route`.
**AWS CLI**
**Pour mettre à jour une route**
L’exemple `update-route` suivant utilise un fichier d’entrée JSON pour mettre à jour les pondérations d’une route.
```
aws appmesh update-route \
--cli-input-json file://update-route-weighted.json
```
Contenu de `update-route-weighted.json` :
```
{
"meshName": "app1",
"routeName": "toVnServiceB-weighted",
"spec": {
"httpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "vnServiceBv1",
"weight": 80
},
{
"virtualNode": "vnServiceBv2",
"weight": 20
}
]
},
"match": {
"prefix": "/"
}
}
},
"virtualRouterName": "vrServiceB"
}
```
Sortie :
```
{
"route": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB/route/toVnServiceB-weighted",
"createdAt": 1563811384.015,
"lastUpdatedAt": 1563819600.022,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"routeName": "toVnServiceB-weighted",
"spec": {
"httpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "vnServiceBv1",
"weight": 80
},
{
"virtualNode": "vnServiceBv2",
"weight": 20
}
]
},
"match": {
"prefix": "/"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "vrServiceB"
}
}
```
Pour plus d’informations, consultez [Routes](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [UpdateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-route.html)la section *Référence des AWS CLI commandes*.
### `update-virtual-node`
L'exemple de code suivant montre comment utiliser`update-virtual-node`.
**AWS CLI**
**Pour mettre à jour un nœud virtuel**
L’exemple `update-virtual-node` suivant utilise un fichier d’entrée JSON pour ajouter une surveillance de l’état à un nœud virtuel.
```
aws appmesh update-virtual-node \
--cli-input-json file://update-virtual-node.json
```
Contenu de `update-virtual-node.json` :
```
{
"clientToken": "500",
"meshName": "app1",
"spec": {
"listeners": [
{
"healthCheck": {
"healthyThreshold": 5,
"intervalMillis": 10000,
"path": "/",
"port": 80,
"protocol": "http",
"timeoutMillis": 3000,
"unhealthyThreshold": 3
},
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv1.svc.cluster.local"
}
}
},
"virtualNodeName": "vnServiceBv1"
}
```
Sortie :
```
{
"virtualNode": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceBv1",
"createdAt": 1563810019.874,
"lastUpdatedAt": 1563819234.825,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"spec": {
"listeners": [
{
"healthCheck": {
"healthyThreshold": 5,
"intervalMillis": 10000,
"path": "/",
"port": 80,
"protocol": "http",
"timeoutMillis": 3000,
"unhealthyThreshold": 3
},
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv1.svc.cluster.local"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualNodeName": "vnServiceBv1"
}
}
```
Pour plus d’informations, consultez [Nœud virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [UpdateVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-virtual-node.html)la section *Référence des AWS CLI commandes*.
### `update-virtual-router`
L'exemple de code suivant montre comment utiliser`update-virtual-router`.
**AWS CLI**
**Pour mettre à jour un routeur virtuel**
L’exemple `update-virtual-router` suivant utilise un fichier d’entrée JSON pour mettre à jour le port de l’écouteur d’un routeur virtuel.
```
aws appmesh update-virtual-router \
--cli-input-json file://update-virtual-router.json
```
Contenu de `update-virtual-router.json` :
```
{
"meshName": "app1",
"spec": {
"listeners": [
{
"portMapping": {
"port": 8080,
"protocol": "http"
}
}
]
},
"virtualRouterName": "vrServiceB"
}
```
Sortie :
```
{
"virtualRouter": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
"createdAt": 1563810546.59,
"lastUpdatedAt": 1563819431.352,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 8080,
"protocol": "http"
}
}
]
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "vrServiceB"
}
}
```
Pour plus d’informations, consultez [Routeurs virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [UpdateVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-virtual-router.html)la section *Référence des AWS CLI commandes*.
### `update-virtual-service`
L'exemple de code suivant montre comment utiliser`update-virtual-service`.
**AWS CLI**
**Pour mettre à jour un service virtuel**
L’exemple `update-virtual-service` suivant utilise un fichier d’entrée JSON pour mettre à jour un service virtuel à utiliser avec un fournisseur de routeur virtuel.
```
aws appmesh update-virtual-service \
--cli-input-json file://update-virtual-service.json
```
Contenu de `update-virtual-service.json` :
```
{
"meshName": "app1",
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "vrServiceA"
}
}
},
"virtualServiceName": "serviceA.svc.cluster.local"
}
```
Sortie :
```
{
"virtualService": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceA.svc.cluster.local",
"createdAt": 1563810859.474,
"lastUpdatedAt": 1563820257.411,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 3
},
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "vrServiceA"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualServiceName": "serviceA.svc.cluster.local"
}
}
```
Pour plus d’informations, consultez [Service virtuels](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) dans le *Guide de l’utilisateur AWS App Mesh*.
+ Pour plus de détails sur l'API, voir [UpdateVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-virtual-service.html)la section *Référence des AWS CLI commandes*.