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 configuration et l’exécution du 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’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 dans le Guide de l’utilisateur 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 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 dans le Guide de l’utilisateur 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’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 dans le Guide de l’utilisateur 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’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-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 Nœud virtuels dans le Guide de l’utilisateur 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’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 dans le Guide de l’utilisateur AWS 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’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 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 _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’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 dans le Guide de l’utilisateur 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 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 dans le Guide de l’utilisateur 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’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 dans le Guide de l’utilisateur 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’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 dans le Guide de l’utilisateur AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous DeleteVirtualRouterà la 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’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 dans le Guide de l’utilisateur AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous DeleteVirtualServiceà la 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’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 dans le Guide de l’utilisateur AWS App Mesh.

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

L'exemple de code suivant montre comment utiliserdescribe-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 dans le Guide de l’utilisateur AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous DescribeRouteà la 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’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 dans le Guide de l’utilisateur AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous DescribeVirtualNodeà la 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’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 dans le Guide de l’utilisateur AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous DescribeVirtualRouterà la 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’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 dans le Guide de l’utilisateur AWS App Mesh.

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

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

AWS CLI

Pour répertorier les maillages de services

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 Maillage de services dans le Guide de l’utilisateur AWS App Mesh.

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

L'exemple de code suivant montre comment utiliserlist-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 dans le Guide de l’utilisateur AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous ListRoutesà la 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’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, reportez-vous ListTagsForResourceà la 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’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 dans le Guide de l’utilisateur AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous ListVirtualNodesà la 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’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 dans le Guide de l’utilisateur AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous ListVirtualRoutersà la 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’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 dans le Guide de l’utilisateur AWS App Mesh.

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

L'exemple de code suivant montre comment utilisertag-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, reportez-vous TagResourceà la section Référence des AWS CLI commandes.

L'exemple de code suivant montre comment utiliseruntag-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, reportez-vous UntagResourceà la 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’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 dans le Guide de l’utilisateur AWS App Mesh.

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

L'exemple de code suivant montre comment utiliserupdate-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 dans le Guide de l’utilisateur AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous UpdateRouteà la 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’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 dans le Guide de l’utilisateur AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous UpdateVirtualNodeà la 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’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 dans le Guide de l’utilisateur AWS App Mesh.

  • Pour plus de détails sur l'API, reportez-vous UpdateVirtualRouterà la 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’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 dans le Guide de l’utilisateur AWS App Mesh.

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