Exemples d'App Mesh utilisant AWS CLI - AWS Exemples de code SDK
Actions

D'autres exemples de AWS SDK sont disponibles dans le référentiel AWS Doc SDK Examples GitHub .

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 façon de configurer et d'exécuter le code en contexte.

Rubriques

Actions

L'exemple de code suivant montre comment utilisercreate-mesh.

AWS CLI

Exemple 1 : pour créer un nouveau maillage de services

L'create-meshexemple 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'create-meshexemple suivant crée un maillage de service 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 Service Meshes dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous CreateMeshà la section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utilisercreate-route.

AWS CLI

Pour créer une nouvelle route gRPC

L'create-routeexemple 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. S'il y a des défaillances spécifiques de 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 nouvelle route HTTP ou HTTP/2

L'create-routeexemple 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 spécifique 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 nouvelle route TCP

L'create-routeexemple 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 dans le guide de l'utilisateur de l'AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous CreateRouteà la section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utilisercreate-virtual-gateway.

AWS CLI

Pour créer une nouvelle passerelle virtuelle

L'create-virtual-gatewayexemple suivant utilise un fichier d'entrée JSON pour créer une passerelle virtuelle avec un écouteur pour HTTP utilisant le 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 Virtual Gateways dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous CreateVirtualGatewayà la section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utilisercreate-virtual-node.

AWS CLI

Exemple 1 : pour créer un nouveau nœud virtuel qui utilise le DNS pour la découverte

L'create-virtual-nodeexemple suivant utilise un fichier d'entrée JSON pour créer un nœud virtuel qui utilise le DNS pour la découverte de services.

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-nodeexemple 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 Virtual Nodes dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous CreateVirtualNodeà la section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utilisercreate-virtual-router.

AWS CLI

Pour créer un nouveau routeur virtuel

L'create-virtual-routerexemple suivant utilise un fichier d'entrée JSON pour créer un routeur virtuel avec un écouteur pour HTTP via le 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 la section Routeurs virtuels dans le guide de l'utilisateur de AWS l'App Mesh.

  • Pour plus de détails sur l'API, reportez-vous CreateVirtualRouterà la section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utilisercreate-virtual-service.

AWS CLI

Exemple 1 : pour créer un nouveau service virtuel avec un fournisseur de nœuds virtuels

L'create-virtual-serviceexemple 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 Virtual Node dans le guide de l'utilisateur d'AWS App Mesh.

Exemple 2 : pour créer un nouveau service virtuel auprès d'un fournisseur de routeur virtuel

L'create-virtual-serviceexemple 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 _services.html> dans le guide de l'utilisateur d'App Mesh AWS

  • Pour plus de détails sur l'API, reportez-vous CreateVirtualServiceà la section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserdelete-mesh.

AWS CLI

Pour supprimer un maillage de services

L'delete-meshexemple suivant supprime le maillage de service 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 Service Meshes dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous DeleteMeshà la section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserdelete-route.

AWS CLI

Pour supprimer un itinéraire

L'delete-routeexemple suivant supprime l'itinéraire spécifié.

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 dans le guide de l'utilisateur de l'AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous DeleteRouteà la section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserdelete-virtual-node.

AWS CLI

Pour supprimer un nœud virtuel

L'delete-virtual-nodeexemple 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 Virtual Nodes dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous DeleteVirtualNodeà la section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserdelete-virtual-router.

AWS CLI

Pour supprimer un routeur virtuel

L'delete-virtual-routerexemple 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 la section Routeurs virtuels dans le guide de l'utilisateur de AWS l'App Mesh.

  • Pour plus de détails sur l'API, voir DeleteVirtualRouterla section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserdelete-virtual-service.

AWS CLI

Pour supprimer un service virtuel

L'delete-virtual-serviceexemple 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 Virtual Service dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, voir DeleteVirtualServicela section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserdescribe-mesh.

AWS CLI

Pour décrire un maillage de services

L'describe-meshexemple suivant renvoie des informations sur le maillage de service 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 Service Meshes dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, voir DescribeMeshla section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserdescribe-route.

AWS CLI

Pour décrire un itinéraire

L'describe-routeexemple suivant renvoie les détails de l'itinéraire spécifié.

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 dans le guide de l'utilisateur de l'AWS App Mesh.

  • Pour plus de détails sur l'API, voir DescribeRoutela section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserdescribe-virtual-node.

AWS CLI

Pour décrire un nœud virtuel

L'describe-virtual-nodeexemple 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 Virtual Nodes dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, voir DescribeVirtualNodela section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserdescribe-virtual-router.

AWS CLI

Pour décrire un routeur virtuel

L'describe-virtual-routerexemple 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 la section Routeurs virtuels dans le guide de l'utilisateur de AWS l'App Mesh.

  • Pour plus de détails sur l'API, voir DescribeVirtualRouterla section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserdescribe-virtual-service.

AWS CLI

Pour décrire un service virtuel

L'describe-virtual-serviceexemple 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 Virtual Services dans le guide de l'utilisateur d'AWS App Mesh.

L'exemple de code suivant montre comment utiliserlist-meshes.

AWS CLI

Pour répertorier les maillages de service

L'list-meshesexemple 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 Service Meshes dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, voir ListMeshesla section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserlist-routes.

AWS CLI

Pour répertorier les itinéraires

L'list-routesexemple 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 dans le guide de l'utilisateur de l'AWS App Mesh.

  • Pour plus de détails sur l'API, voir ListRoutesla section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserlist-tags-for-resource.

AWS CLI

Pour répertorier les balises d'une ressource

L'list-tags-for-resourceexemple 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 ListTagsForResourcela section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserlist-virtual-nodes.

AWS CLI

Pour répertorier les nœuds virtuels

L'list-virtual-nodesexemple suivant répertorie tous les nœuds virtuels du maillage de service 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 Virtual Nodes dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, voir ListVirtualNodesla section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserlist-virtual-routers.

AWS CLI

Pour répertorier les routeurs virtuels

L'list-virtual-routersexemple suivant répertorie tous les routeurs virtuels du maillage de service 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 la section Routeurs virtuels dans le guide de l'utilisateur de AWS l'App Mesh.

  • Pour plus de détails sur l'API, voir ListVirtualRoutersla section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserlist-virtual-services.

AWS CLI

Pour répertorier les services virtuels

L'list-virtual-servicesexemple suivant répertorie tous les services virtuels du 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 Virtual Services dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, voir ListVirtualServicesla section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utilisertag-resource.

AWS CLI

Pour étiqueter une ressource

L'tag-resourceexemple 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 aucun résultat.

  • Pour plus de détails sur l'API, voir TagResourcela section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliseruntag-resource.

AWS CLI

Pour annuler le balisage d'une ressource

L'untag-resourceexemple suivant supprime une balise contenant 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 aucun résultat.

  • Pour plus de détails sur l'API, voir UntagResourcela section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserupdate-mesh.

AWS CLI

Pour mettre à jour un maillage de services

L'update-meshexemple suivant utilise un fichier d'entrée JSON pour mettre à jour un maillage de service 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 Service Meshes dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, voir UpdateMeshla section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserupdate-route.

AWS CLI

Pour mettre à jour un itinéraire

L'update-routeexemple suivant utilise un fichier d'entrée JSON pour mettre à jour les pondérations d'un itinéraire.

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 dans le guide de l'utilisateur de l'AWS App Mesh.

  • Pour plus de détails sur l'API, voir UpdateRoutela section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserupdate-virtual-node.

AWS CLI

Pour mettre à jour un nœud virtuel

L'update-virtual-nodeexemple suivant utilise un fichier d'entrée JSON pour ajouter un contrôle de santé à 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 Virtual Nodes dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, voir UpdateVirtualNodela section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserupdate-virtual-router.

AWS CLI

Pour mettre à jour un routeur virtuel

L'update-virtual-routerexemple suivant utilise un fichier d'entrée JSON pour mettre à jour le port d'écoute 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 la section Routeurs virtuels dans le guide de l'utilisateur de AWS l'App Mesh.

  • Pour plus de détails sur l'API, voir UpdateVirtualRouterla section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliserupdate-virtual-service.

AWS CLI

Pour mettre à jour un service virtuel

L'update-virtual-serviceexemple suivant utilise un fichier d'entrée JSON pour mettre à jour un service virtuel afin d'utiliser 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 Virtual Services dans le guide de l'utilisateur d'AWS App Mesh.

  • Pour plus de détails sur l'API, voir UpdateVirtualServicela section Référence des AWS CLI commandes.