Ejemplos de App Mesh que utilizan la AWS CLI - AWS Command Line Interface
Acciones

Ejemplos de App Mesh que utilizan la AWS CLI

En los siguientes ejemplos de código se muestra cómo realizar acciones e implementar situaciones comunes usando la AWS Command Line Interface con App Mesh.

Las acciones son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las funciones de servicio individuales, es posible ver las acciones en contexto en los escenarios relacionados.

En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.

Acciones

En el siguiente ejemplo de código, se muestra cómo utilizar create-mesh.

AWS CLI

Ejemplo 1: cómo crear una nueva malla de servicios

En el siguiente ejemplo de create-mesh, se crea una malla de servicios.

aws appmesh create-mesh \
    --mesh-name app1

Salida:

{
    "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"
        }
    }
}

Ejemplo 2: cómo crear una nueva malla de servicios con varias etiquetas

En el siguiente ejemplo de create-mesh, se crea una malla de servicios con varias etiquetas.

aws appmesh create-mesh \
    --mesh-name app2 \
    --tags key=key1,value=value1 key=key2,value=value2 key=key3,value=value3

Salida:

{
    "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"
        }
    }
}

Para obtener más información, consulte Service Meshes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte CreateMesh en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar create-route.

AWS CLI

Creación de una nueva ruta gRPC

En el siguiente ejemplo de create-route, se usa un archivo de entrada JSON para crear una ruta gRPC. El tráfico de GRPC que tiene metadatos que comienzan por 123 se enruta a un nodo virtual denominado serviceBgrpc. Si hay errores específicos de gRPC, HTTP o TCP, al intentar comunicarse con el destino de la ruta, se vuelve a intentar la ruta tres veces. Hay un retraso de 15 segundos entre cada reintento.

aws appmesh create-route \
    --cli-input-json file://create-route-grpc.json

Contenido 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"
}

Salida:

{
    "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"
    }
}

Creación de una nueva ruta HTTP o HTTP/2

En el siguiente ejemplo de create-route, se usa un archivo de entrada JSON para crear una ruta HTTP/2. Para crear una ruta HTTP, sustituya http2Route por httpRoute según las especificaciones. Todo el tráfico HTTP/2 dirigido a cualquier prefijo de URL que tenga un valor de encabezado que comience por 123 se enruta a un nodo virtual denominado serviceBhttp2. Si hay errores específicos de HTTP o TCP al intentar comunicarse con el destino de la ruta, se vuelve a intentar la ruta tres veces. Hay un retraso de 15 segundos entre cada reintento.

aws appmesh create-route \
    --cli-input-json file://create-route-http2.json

Contenido 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"
}

Salida:

{
    "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"
    }
}

Creación de una nueva ruta de TCP

En el siguiente ejemplo de create-route, se utiliza un archivo de entrada JSON para crear una ruta de TCP. El 75 por ciento del tráfico se enruta a un nodo virtual denominado serviceBtcp y el 25 por ciento del tráfico se enruta a un nodo virtual denominado serviceBv2tcp. Especificar diferentes ponderaciones para distintos destinos es una forma eficaz de implementar una nueva versión de una aplicación. Puede ajustar las ponderaciones para que, en última instancia, el cien por cien de todo el tráfico se enrute a un destino que tenga la nueva versión de una aplicación.

aws appmesh create-route \
    --cli-input-json file://create-route-tcp.json

Contenido de create-route-tcp.json:

{
    "meshName": "apps",
    "routeName": "tcpRoute",
    "spec": {
        "priority": 300,
        "tcpRoute": {
            "action": {
                "weightedTargets": [
                    {
                        "virtualNode": "serviceBtcp",
                        "weight": 75
                    },
                    {
                        "virtualNode": "serviceBv2tcp",
                        "weight": 25
                    }
                ]
            }
        }
    },
    "virtualRouterName": "serviceBtcp"
}

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Routes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte CreateRoute en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar create-virtual-gateway.

AWS CLI

Creación de una nueva puerta de enlace virtual

El siguiente ejemplo de create-virtual-gateway, se utiliza un archivo de entrada JSON para crear una puerta de enlace virtual con un oyente para HTTP mediante el puerto 9080.

aws appmesh create-virtual-gateway \
    --mesh-name meshName \
    --virtual-gateway-name virtualGatewayName \
    --cli-input-json file://create-virtual-gateway.json

Contenido de create-virtual-gateway.json:

{
    "spec": {
      "listeners": [
        {
          "portMapping": {
            "port": 9080,
            "protocol": "http"
          }
        }
      ]
    }
}

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Gateways en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte CreateVirtualGateway en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar create-virtual-node.

AWS CLI

Ejemplo 1: cómo crear un nuevo nodo virtual que utilice DNS para la detección

En el siguiente ejemplo de create-virtual-node, se usa un archivo de entrada JSON para crear un nodo virtual que utilice DNS para la detección de servicios.

aws appmesh create-virtual-node \
    --cli-input-json file://create-virtual-node-dns.json

Contenido de create-virtual-node-dns.json:

{
    "meshName": "app1",
    "spec": {
        "listeners": [
            {
                "portMapping": {
                    "port": 80,
                    "protocol": "http"
                }
            }
        ],
        "serviceDiscovery": {
            "dns": {
                "hostname": "serviceBv1.svc.cluster.local"
            }
        }
    },
    "virtualNodeName": "vnServiceBv1"
}

Salida:

{
    "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"
    }
}

Ejemplo 2: cómo crear un nuevo nodo virtual que utilice AWS Cloud Map para la detección

En el siguiente ejemplo de create-virtual-node, se usa un archivo de entrada JSON para crear un nodo virtual que utilice AWS Cloud Map para la detección de servicios.

aws appmesh create-virtual-node \
    --cli-input-json file://create-virtual-node-cloud-map.json

Contenido 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"
}

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Nodes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte CreateVirtualNode en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar create-virtual-router.

AWS CLI

Creación de un nuevo enrutador virtual

El siguiente ejemplo de create-virtual-router, se utiliza un archivo de entrada JSON para crear un enrutador virtual con un oyente para HTTP mediante el puerto 80.

aws appmesh create-virtual-router \
    --cli-input-json file://create-virtual-router.json

Contenido de create-virtual-router.json:

{
    "meshName": "app1",
    "spec": {
        "listeners": [
            {
                "portMapping": {
                    "port": 80,
                    "protocol": "http"
                }
            }
        ]
    },
    "virtualRouterName": "vrServiceB"
}

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Routers en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte CreateVirtualRouter en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar create-virtual-service.

AWS CLI

Ejemplo 1: cómo crear un nuevo servicio virtual con un proveedor de nodos virtuales

En el siguiente ejemplo de create-virtual-service, se usa un archivo de entrada JSON para crear un servicio virtual con un proveedor de nodos virtuales.

aws appmesh create-virtual-service \
    --cli-input-json file://create-virtual-service-virtual-node.json

Contenido de create-virtual-service-virtual-node.json:

{
    "meshName": "app1",
    "spec": {
        "provider": {
            "virtualNode": {
                "virtualNodeName": "vnServiceA"
            }
        }
    },
    "virtualServiceName": "serviceA.svc.cluster.local"
}

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Node en la Guía del usuario de AWS App Mesh.

Ejemplo 2: cómo crear un nuevo servicio virtual con un proveedor de enrutadores virtuales

En el siguiente ejemplo de create-virtual-service, se usa un archivo de entrada JSON para crear un servicio virtual con un proveedor de enrutadores virtuales.

aws appmesh create-virtual-service \
    --cli-input-json file://create-virtual-service-virtual-router.json

Contenido de create-virtual-service-virtual-router.json:

{
    "meshName": "app1",
    "spec": {
        "provider": {
            "virtualRouter": {
                "virtualRouterName": "vrServiceB"
            }
        }
    },
    "virtualServiceName": "serviceB.svc.cluster.local"
}

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Services<https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html> en la Guía del usuario de AWS App Mesh

  • Para obtener información sobre la API, consulte CreateVirtualService en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar delete-mesh.

AWS CLI

Eliminación de una malla de servicios

En el siguiente ejemplo de delete-mesh, se elimina la malla de servicios especificada.

aws appmesh delete-mesh \
    --mesh-name app1

Salida:

{
    "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"
        }
    }
}

Para obtener más información, consulte Service Meshes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte DeleteMesh en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar delete-route.

AWS CLI

Para eliminar una ruta

En el siguiente ejemplo de delete-route, se elimina la ruta especificada.

aws appmesh delete-route \
    --mesh-name app1 \
    --virtual-router-name vrServiceB \
    --route-name toVnServiceB-weighted

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Routes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte DeleteRoute en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar delete-virtual-node.

AWS CLI

Eliminación de un nodo virtual

En el siguiente ejemplo de delete-virtual-node, se elimina el nodo virtual especificado.

aws appmesh delete-virtual-node \
    --mesh-name app1 \
    --virtual-node-name vnServiceBv2

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Nodes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte DeleteVirtualNode en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar delete-virtual-router.

AWS CLI

Eliminación de un enrutador virtual

En el siguiente ejemplo de delete-virtual-router, se elimina el enrutador virtual especificado.

aws appmesh delete-virtual-router \
    --mesh-name app1 \
    --virtual-router-name vrServiceB

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Routers en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte DeleteVirtualRouter en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar delete-virtual-service.

AWS CLI

Eliminación de un servicio virtual

En el siguiente ejemplo de delete-virtual-service, se elimina el servicio virtual especificado.

aws appmesh delete-virtual-service \
    --mesh-name app1 \
    --virtual-service-name serviceB.svc.cluster.local

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Service en la Guía del usuario de AWS.

  • Para obtener información sobre la API, consulte DeleteVirtualService en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-mesh.

AWS CLI

Para describir una malla de servicios

En el siguiente ejemplo de describe-mesh, se ofrecen detalles sobre la malla de servicios especificada.

aws appmesh describe-mesh \
    --mesh-name app1

Salida:

{
    "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"
        }
    }
}

Para obtener más información, consulte Service Meshes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte DescribeMesh en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-route.

AWS CLI

Descripción de una ruta

En el siguiente ejemplo de describe-route, se ofrecen detalles sobre la ruta especificada.

aws appmesh describe-route \
    --mesh-name app1 \
    --virtual-router-name vrServiceB \
    --route-name toVnServiceB-weighted

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Routes en la Guía del usuario de AWS App Mesh.

  • Para obtener más información sobre la API, consulte DescribeRoute en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-virtual-node.

AWS CLI

Descripción de un nodo virtual

En el siguiente ejemplo de describe-virtual-node, se ofrecen detalles sobre el nodo virtual especificado.

aws appmesh describe-virtual-node \
    --mesh-name app1 \
    --virtual-node-name vnServiceBv1

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Nodes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte DescribeVirtualNode en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-virtual-router.

AWS CLI

Descripción de un enrutador virtual

En el siguiente ejemplo de describe-virtual-router, se ofrecen detalles sobre el enrutador virtual especificado.

aws appmesh describe-virtual-router \
    --mesh-name app1 \
    --virtual-router-name vrServiceB

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Routers en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte DescribeVirtualRouter en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar describe-virtual-service.

AWS CLI

Descripción de un servicio virtual

En el siguiente ejemplo de describe-virtual-service, se ofrecen detalles sobre el servicio virtual especificado.

aws appmesh describe-virtual-service \
    --mesh-name app1 \
    --virtual-service-name serviceB.svc.cluster.local

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Services en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte DescribeVirtualService en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar list-meshes.

AWS CLI

Generación de una lista de mallas de servicio

En el siguiente ejemplo de list-meshes, se genera una lista de todas las mallas de servicio de la región de AWS actual.

aws appmesh list-meshes

Salida:

{
    "meshes": [
        {
            "arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
            "meshName": "app1"
        }
    ]
}

Para obtener más información, consulte Service Meshes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte ListMeshes en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar list-routes.

AWS CLI

Generación de una lista de las rutas

En el siguiente list-routes ejemplo, se genera una lista de todas las rutas del enrutador virtual especificado.

aws appmesh list-routes \
    --mesh-name app1 \
    --virtual-router-name vrServiceB

Salida:

{
    "routes": [
        {
            "arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB/route/toVnServiceB",
            "meshName": "app1",
            "routeName": "toVnServiceB-weighted",
            "virtualRouterName": "vrServiceB"
        }
    ]
}

Para obtener más información, consulte Routes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte ListRoutes en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar list-tags-for-resource.

AWS CLI

Para enumerar las etiquetas de un recurso

En el siguiente ejemplo de list-tags-for-resource, se genera una lista de todas las etiquetas asignadas al recurso especificado.

aws appmesh list-tags-for-resource \
    --resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1

Salida:

{
    "tags": [
        {
            "key": "key1",
            "value": "value1"
        },
        {
            "key": "key2",
            "value": "value2"
        },
        {
            "key": "key3",
            "value": "value3"
        }
    ]
}

  • Para obtener información sobre la API, consulte ListTagsForResource en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar list-virtual-nodes.

AWS CLI

Generación de una lista de nodos virtuales

En el siguiente ejemplo de list-virtual-nodes, se genera una lista de todos los nodos virtuales de la malla de servicios especificada.

aws appmesh list-virtual-nodes \
    --mesh-name app1

Salida:

{
    "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"
        }
    ]
}

Para obtener más información, consulte Virtual Nodes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte ListVirtualNodes en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar list-virtual-routers.

AWS CLI

Generación de una lista de enrutadores virtuales

En el siguiente ejemplo de list-virtual-routers, se genera una lista de todos los enrutadores virtuales de la malla de servicios especificada.

aws appmesh list-virtual-routers \
    --mesh-name app1

Salida:

{
    "virtualRouters": [
        {
            "arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
            "meshName": "app1",
            "virtualRouterName": "vrServiceB"
        }
    ]
}

Para obtener más información, consulte Virtual Routers en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte ListVirtualRouters en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar list-virtual-services.

AWS CLI

Generación de una lista de servicios virtuales

En el siguiente ejemplo de list-virtual-services, se genera una lista de todos los servicios virtuales de la malla de servicios especificada.

aws appmesh list-virtual-services \
    --mesh-name app1

Salida:

{
    "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"
        }
    ]
}

Para obtener más información, consulte Virtual Services en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte ListVirtualServices en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar tag-resource.

AWS CLI

Para etiquetar un recurso

En el siguiente ejemplo de tag-resource, se añade la etiqueta key1 con el valor value1 al recurso especificado.

aws appmesh tag-resource \
    --resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1 \
    --tags key=key1,value=value1

Este comando no genera ninguna salida.

  • Para ver los detalles de la API, consulte TagResource en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar untag-resource.

AWS CLI

Para retirar la etiqueta de un recurso

En el siguiente ejemplo de untag-resource, se elimina una etiqueta con la clave key1 del recurso especificado.

aws appmesh untag-resource \
    --resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1 \
    --tag-keys key1

Este comando no genera ninguna salida.

  • Para obtener información sobre la API, consulte UntagResource en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar update-mesh.

AWS CLI

Actualización de una malla de servicios

En el siguiente ejemplo de update-mesh, se utiliza un archivo de entrada JSON para actualizar una malla de servicios y permitir que todo el tráfico de salida externo se reenvíe intacto a través del proxy de Envoy.

aws appmesh update-mesh \
    --cli-input-json file://update-mesh.json

Contenido de update-mesh.json:

{
    "meshName": "app1",
    "spec": {
        "egressFilter": {
            "type": "ALLOW_ALL"
        }
    }
}

Salida:

{
    "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"
        }
    }
}

Para obtener más información, consulte Service Meshes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte UpdateMesh en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar update-route.

AWS CLI

Actualización de una ruta

En el siguiente ejemplo de update-route, se utiliza un archivo de entrada JSON para actualizar las ponderaciones de una ruta.

aws appmesh update-route \
    --cli-input-json file://update-route-weighted.json

Contenido 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"
}

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Routes en la Guía del usuario de AWS App Mesh.

  • Para obtener más información sobre la API, consulte UpdateRoute en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar update-virtual-node.

AWS CLI

Actualización de un nodo virtual

En el siguiente ejemplo de update-virtual-node, se utiliza un archivo de entrada JSON para añadir una comprobación de estado a un nodo virtual.

aws appmesh update-virtual-node \
    --cli-input-json file://update-virtual-node.json

Contenido 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"
}

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Nodes en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte UpdateVirtualNode en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar update-virtual-router.

AWS CLI

Actualización de un enrutador virtual

El siguiente ejemplo de update-virtual-router, se utiliza un archivo de entrada JSON para actualizar un puerto de oyente de enrutador virtual.

aws appmesh update-virtual-router \
    --cli-input-json file://update-virtual-router.json

Contenido de update-virtual-router.json:

{
    "meshName": "app1",
    "spec": {
        "listeners": [
            {
                "portMapping": {
                    "port": 8080,
                    "protocol": "http"
                }
            }
        ]
    },
    "virtualRouterName": "vrServiceB"
}

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Routers en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte UpdateVirtualRouter en la Referencia de comandos de la AWS CLI.

En el siguiente ejemplo de código, se muestra cómo utilizar update-virtual-service.

AWS CLI

Actualización de un servicio virtual

En el siguiente ejemplo de update-virtual-service, se usa un archivo de entrada JSON para actualizar un servicio virtual de manera que utilice un proveedor de enrutadores virtuales.

aws appmesh update-virtual-service \
    --cli-input-json file://update-virtual-service.json

Contenido de update-virtual-service.json:

{
    "meshName": "app1",
    "spec": {
        "provider": {
            "virtualRouter": {
                "virtualRouterName": "vrServiceA"
            }
        }
    },
    "virtualServiceName": "serviceA.svc.cluster.local"
}

Salida:

{
    "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"
    }
}

Para obtener más información, consulte Virtual Services en la Guía del usuario de AWS App Mesh.

  • Para obtener información sobre la API, consulte UpdateVirtualService en la Referencia de comandos de la AWS CLI.