Exemples d'App Mesh utilisant AWS CLI - AWS Command Line Interface
Actions

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. Les actions vous indiquent comment appeler des fonctions de service individuelles, mais vous pouvez les visualiser dans leur contexte dans les scénarios correspondants.

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 API plus de détails, voir CreateMeshla section Référence des AWS CLI commandes.

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

AWS CLI

Pour créer un nouvel RPC itinéraire G

L'create-routeexemple suivant utilise un fichier JSON d'entrée pour créer un RPC itinéraire g. GRPCle trafic dont les métadonnées commencent par 123 est acheminé vers un nœud virtuel nomméserviceBgrpc. En cas d'TCPéchec ou d'RPCéchec spécifique lors de la tentative de communication avec la cible de la route, la route est réessayée trois fois. HTTP 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 un nouvel itinéraire HTTP ou un itinéraire HTTP /2

L'create-routeexemple suivant utilise un fichier JSON d'entrée pour créer une route HTTP /2. Pour créer une HTTP route, remplacez Http2Route par httpRoute under spec. Tout le trafic HTTP /2 adressé à un URL préfixe dont la valeur d'en-tête commence par 123 est acheminé vers un nœud virtuel nommé serviceBhttp 2. En cas de tentative de communication spécifique HTTP ou en cas d'TCPéchec lors de la tentative de communication avec la cible de l'itinéraire, celui-ci est réessayé 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 un nouvel TCP itinéraire

L'create-routeexemple suivant utilise un fichier JSON d'entrée pour créer un TCP itinéraire. 75 % du trafic est acheminé vers un nœud virtuel nomméserviceBtcp, et 25 % du trafic est acheminé vers un nœud virtuel nommé serviceBv 2tcp. 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 API plus de détails, voir CreateRoutela 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 JSON d'entrée pour créer une passerelle virtuelle avec un écouteur pour HTTP utiliser 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.

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

AWS CLI

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

L'create-virtual-nodeexemple suivant utilise un fichier JSON d'entrée pour créer un nœud virtuel utilisé 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 JSON d'entrée 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 API plus de détails, voir CreateVirtualNodela 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 JSON d'entrée pour créer un routeur virtuel avec un écouteur pour HTTP utiliser 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 API plus de détails, voir CreateVirtualRouterla 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 JSON d'entrée 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 JSON d'entrée 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

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 API plus de détails, voir DeleteMeshla 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 API plus de détails, voir DeleteRoutela 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 API plus de détails, voir DeleteVirtualNodela 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 API plus de détails, 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.

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 API plus de détails, 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 API plus de détails, 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 API plus de détails, 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.

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 API plus de détails, 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 API plus de détails, 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 API plus de détails, 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 API plus de détails, 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 API plus de détails, 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 API plus de détails, 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 API plus de détails, 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 API plus de détails, 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 JSON d'entrée 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 API plus de détails, 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 JSON d'entrée 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 API plus de détails, 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 JSON d'entrée 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 API plus de détails, 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 JSON d'entrée 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 API plus de détails, 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 JSON d'entrée 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.