Ada lebih banyak contoh AWS SDK yang tersedia di repo Contoh [SDK AWS Doc](https://github.com/awsdocs/aws-doc-sdk-examples). GitHub 

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Contoh App Mesh menggunakan AWS CLI
<a name="cli_2_app-mesh_code_examples"></a>

Contoh kode berikut menunjukkan cara melakukan tindakan dan mengimplementasikan skenario umum dengan menggunakan App Mesh AWS Command Line Interface with.

*Tindakan* merupakan kutipan kode dari program yang lebih besar dan harus dijalankan dalam konteks. Sementara tindakan menunjukkan cara memanggil fungsi layanan individual, Anda dapat melihat tindakan dalam konteks dalam skenario terkait.

Setiap contoh menyertakan tautan ke kode sumber lengkap, di mana Anda dapat menemukan instruksi tentang cara mengatur dan menjalankan kode dalam konteks.

**Topics**
+ [Tindakan](#actions)

## Tindakan
<a name="actions"></a>

### `create-mesh`
<a name="app-mesh_CreateMesh_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`create-mesh`.

**AWS CLI**  
**Contoh 1: Untuk membuat mesh layanan baru**  
`create-mesh`Contoh berikut membuat mesh layanan.  

```
aws appmesh create-mesh \
    --mesh-name app1
```
Output:  

```
{
    "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"
        }
    }
}
```
**Contoh 2: Untuk membuat mesh layanan baru dengan beberapa tag**  
`create-mesh`Contoh berikut membuat mesh layanan dengan beberapa tag.  

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

```
{
    "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"
        }
    }
}
```
Untuk informasi selengkapnya, lihat [Service Meshes](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [CreateMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-mesh.html)di *Referensi AWS CLI Perintah*. 

### `create-route`
<a name="app-mesh_CreateRoute_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`create-route`.

**AWS CLI**  
**Untuk membuat rute gRPC baru**  
`create-route`Contoh berikut menggunakan file input JSON untuk membuat rute gRPC. Lalu lintas GRPC yang memiliki metadata yang dimulai dengan 123 dirutekan ke node virtual bernama ServiceBGRPC. Jika ada kegagalan gRPC, HTTP, atau TCP tertentu saat mencoba berkomunikasi dengan target rute, rute dicoba ulang tiga kali. Ada penundaan 15 detik antara setiap upaya coba lagi.  

```
aws appmesh create-route \
    --cli-input-json file://create-route-grpc.json
```
Isi dari `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"
}
```
Output:  

```
{
    "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"
    }
}
```
**Untuk membuat rute HTTP atau HTTP/2 baru**  
`create-route`Contoh berikut menggunakan file input JSON untuk membuat rute HTTP/2. Untuk membuat rute HTTP, ganti Http2Route dengan HttpRoute di bawah spesifikasi. Semua lalu lintas HTTP/2 yang ditujukan ke awalan URL apa pun yang memiliki nilai header yang dimulai dengan 123 dirutekan ke node virtual bernama ServiceBHTTP2. Jika ada kegagalan HTTP atau TCP tertentu ketika mencoba berkomunikasi dengan target rute, rute dicoba ulang tiga kali. Ada penundaan 15 detik antara setiap upaya coba lagi.  

```
aws appmesh create-route \
    --cli-input-json file://create-route-http2.json
```
Isi dari `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"
}
```
Output:  

```
{
    "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"
    }
}
```
**Untuk membuat rute TCP baru**  
`create-route`Contoh berikut menggunakan file input JSON untuk membuat rute TCP. 75 persen lalu lintas dirutekan ke node virtual bernama ServiceBTCP, dan 25 persen lalu lintas dirutekan ke node virtual bernama ServiceBV2TCP. Menentukan bobot yang berbeda untuk target yang berbeda adalah cara yang efektif untuk melakukan penerapan versi baru aplikasi. Anda dapat menyesuaikan bobot sehingga pada akhirnya, 100 persen dari semua lalu lintas diarahkan ke target yang memiliki versi baru aplikasi.  

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

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

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Rute](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [CreateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-route.html)di *Referensi AWS CLI Perintah*. 

### `create-virtual-gateway`
<a name="app-mesh_CreateVirtualGateway_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`create-virtual-gateway`.

**AWS CLI**  
**Untuk membuat gateway virtual baru**  
`create-virtual-gateway`Contoh berikut menggunakan file input JSON untuk membuat gateway virtual dengan pendengar untuk HTTP menggunakan port 9080.  

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

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

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Gateway Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_gateways.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [CreateVirtualGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-gateway.html)di *Referensi AWS CLI Perintah*. 

### `create-virtual-node`
<a name="app-mesh_CreateVirtualNode_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`create-virtual-node`.

**AWS CLI**  
**Contoh 1: Untuk membuat node virtual baru yang menggunakan DNS untuk penemuan**  
`create-virtual-node`Contoh berikut menggunakan file input JSON untuk membuat node virtual yang menggunakan DNS untuk penemuan layanan.  

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

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

```
{
    "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"
    }
}
```
**Contoh 2: Untuk membuat node virtual baru yang menggunakan AWS Cloud Map untuk penemuan**  
`create-virtual-node`Contoh berikut menggunakan file input JSON untuk membuat node virtual yang menggunakan AWS Cloud Map untuk penemuan layanan.  

```
aws appmesh create-virtual-node \
    --cli-input-json file://create-virtual-node-cloud-map.json
```
Isi dari `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"
}
```
Output:  

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Node Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [CreateVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-node.html)di *Referensi AWS CLI Perintah*. 

### `create-virtual-router`
<a name="app-mesh_CreateVirtualRouter_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`create-virtual-router`.

**AWS CLI**  
**Untuk membuat router virtual baru**  
`create-virtual-router`Contoh berikut menggunakan file input JSON untuk membuat router virtual dengan pendengar untuk HTTP menggunakan port 80.  

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

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

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Router Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [CreateVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-router.html)di *Referensi AWS CLI Perintah*. 

### `create-virtual-service`
<a name="app-mesh_CreateVirtualService_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`create-virtual-service`.

**AWS CLI**  
**Contoh 1: Untuk membuat layanan virtual baru dengan penyedia node virtual**  
`create-virtual-service`Contoh berikut menggunakan file input JSON untuk membuat layanan virtual dengan penyedia node virtual.  

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

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

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Node Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) di *Panduan Pengguna AWS App Mesh*.  
**Contoh 2: Untuk membuat layanan virtual baru dengan penyedia router virtual**  
`create-virtual-service`Contoh berikut menggunakan file input JSON untuk membuat layanan virtual dengan penyedia router virtual.  

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

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

```
{
    "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"
    }
}
```
*Untuk informasi selengkapnya, lihat Layanan Virtual< https://docs.aws.amazon.com/app-mesh/ latest/userguide/virtual \$1services.html> di Panduan Pengguna App Mesh AWS *  
+  Untuk detail API, lihat [CreateVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-service.html)di *Referensi AWS CLI Perintah*. 

### `delete-mesh`
<a name="app-mesh_DeleteMesh_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`delete-mesh`.

**AWS CLI**  
**Untuk menghapus mesh layanan**  
`delete-mesh`Contoh berikut menghapus mesh layanan yang ditentukan.  

```
aws appmesh delete-mesh \
    --mesh-name app1
```
Output:  

```
{
    "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"
        }
    }
}
```
Untuk informasi selengkapnya, lihat [Service Meshes](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [DeleteMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-mesh.html)di *Referensi AWS CLI Perintah*. 

### `delete-route`
<a name="app-mesh_DeleteRoute_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`delete-route`.

**AWS CLI**  
**Untuk menghapus rute**  
`delete-route`Contoh berikut menghapus rute yang ditentukan.  

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

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Rute](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [DeleteRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-route.html)di *Referensi AWS CLI Perintah*. 

### `delete-virtual-node`
<a name="app-mesh_DeleteVirtualNode_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`delete-virtual-node`.

**AWS CLI**  
**Untuk menghapus node virtual**  
`delete-virtual-node`Contoh berikut menghapus node virtual yang ditentukan.  

```
aws appmesh delete-virtual-node \
    --mesh-name app1 \
    --virtual-node-name vnServiceBv2
```
Output:  

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Node Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [DeleteVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-virtual-node.html)di *Referensi AWS CLI Perintah*. 

### `delete-virtual-router`
<a name="app-mesh_DeleteVirtualRouter_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`delete-virtual-router`.

**AWS CLI**  
**Untuk menghapus router virtual**  
`delete-virtual-router`Contoh berikut menghapus router virtual yang ditentukan.  

```
aws appmesh delete-virtual-router \
    --mesh-name app1 \
    --virtual-router-name vrServiceB
```
Output:  

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Router Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [DeleteVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-virtual-router.html)di *Referensi AWS CLI Perintah*. 

### `delete-virtual-service`
<a name="app-mesh_DeleteVirtualService_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`delete-virtual-service`.

**AWS CLI**  
**Untuk menghapus layanan virtual**  
`delete-virtual-service`Contoh berikut menghapus layanan virtual yang ditentukan.  

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

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Layanan Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [DeleteVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-virtual-service.html)di *Referensi AWS CLI Perintah*. 

### `describe-mesh`
<a name="app-mesh_DescribeMesh_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`describe-mesh`.

**AWS CLI**  
**Untuk menggambarkan mesh layanan**  
`describe-mesh`Contoh berikut mengembalikan rincian tentang mesh layanan tertentu.  

```
aws appmesh describe-mesh \
    --mesh-name app1
```
Output:  

```
{
    "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"
        }
    }
}
```
Untuk informasi selengkapnya, lihat [Service Meshes](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [DescribeMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-mesh.html)di *Referensi AWS CLI Perintah*. 

### `describe-route`
<a name="app-mesh_DescribeRoute_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`describe-route`.

**AWS CLI**  
**Untuk menggambarkan rute**  
`describe-route`Contoh berikut mengembalikan rincian tentang rute yang ditentukan.  

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

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Rute](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [DescribeRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-route.html)di *Referensi AWS CLI Perintah*. 

### `describe-virtual-node`
<a name="app-mesh_DescribeVirtualNode_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`describe-virtual-node`.

**AWS CLI**  
**Untuk menggambarkan simpul virtual**  
`describe-virtual-node`Contoh berikut mengembalikan rincian tentang node virtual tertentu.  

```
aws appmesh describe-virtual-node \
    --mesh-name app1 \
    --virtual-node-name vnServiceBv1
```
Output:  

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Node Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [DescribeVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-virtual-node.html)di *Referensi AWS CLI Perintah*. 

### `describe-virtual-router`
<a name="app-mesh_DescribeVirtualRouter_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`describe-virtual-router`.

**AWS CLI**  
**Untuk menggambarkan router virtual**  
`describe-virtual-router`Contoh berikut mengembalikan rincian tentang router virtual yang ditentukan.  

```
aws appmesh describe-virtual-router \
    --mesh-name app1 \
    --virtual-router-name vrServiceB
```
Output:  

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Router Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [DescribeVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-virtual-router.html)di *Referensi AWS CLI Perintah*. 

### `describe-virtual-service`
<a name="app-mesh_DescribeVirtualService_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`describe-virtual-service`.

**AWS CLI**  
**Untuk menggambarkan layanan virtual**  
`describe-virtual-service`Contoh berikut mengembalikan rincian tentang layanan virtual yang ditentukan.  

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

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Layanan Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [DescribeVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-virtual-service.html)di *Referensi AWS CLI Perintah*. 

### `list-meshes`
<a name="app-mesh_ListMeshes_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`list-meshes`.

**AWS CLI**  
**Untuk membuat daftar jerat layanan**  
`list-meshes`Contoh berikut mencantumkan semua jerat layanan di AWS Wilayah saat ini.  

```
aws appmesh list-meshes
```
Output:  

```
{
    "meshes": [
        {
            "arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
            "meshName": "app1"
        }
    ]
}
```
Untuk informasi selengkapnya, lihat [Service Meshes](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [ListMeshes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-meshes.html)di *Referensi AWS CLI Perintah*. 

### `list-routes`
<a name="app-mesh_ListRoutes_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`list-routes`.

**AWS CLI**  
**Untuk daftar rute**  
`list-routes`Contoh berikut mencantumkan semua rute untuk router virtual yang ditentukan.  

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

```
{
    "routes": [
        {
            "arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB/route/toVnServiceB",
            "meshName": "app1",
            "routeName": "toVnServiceB-weighted",
            "virtualRouterName": "vrServiceB"
        }
    ]
}
```
Untuk informasi selengkapnya, lihat [Rute](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [ListRoutes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-routes.html)di *Referensi AWS CLI Perintah*. 

### `list-tags-for-resource`
<a name="app-mesh_ListTagsForResource_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`list-tags-for-resource`.

**AWS CLI**  
**Untuk membuat daftar tag untuk sumber daya**  
`list-tags-for-resource`Contoh berikut mencantumkan semua tag yang ditetapkan ke sumber daya yang ditentukan.  

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

```
{
    "tags": [
        {
            "key": "key1",
            "value": "value1"
        },
        {
            "key": "key2",
            "value": "value2"
        },
        {
            "key": "key3",
            "value": "value3"
        }
    ]
}
```
+  Untuk detail API, lihat [ListTagsForResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-tags-for-resource.html)di *Referensi AWS CLI Perintah*. 

### `list-virtual-nodes`
<a name="app-mesh_ListVirtualNodes_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`list-virtual-nodes`.

**AWS CLI**  
**Untuk daftar node virtual**  
`list-virtual-nodes`Contoh berikut mencantumkan semua node virtual di mesh layanan tertentu.  

```
aws appmesh list-virtual-nodes \
    --mesh-name app1
```
Output:  

```
{
    "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"
        }
    ]
}
```
Untuk informasi selengkapnya, lihat [Node Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [ListVirtualNodes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-virtual-nodes.html)di *Referensi AWS CLI Perintah*. 

### `list-virtual-routers`
<a name="app-mesh_ListVirtualRouters_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`list-virtual-routers`.

**AWS CLI**  
**Untuk daftar router virtual**  
`list-virtual-routers`Contoh berikut mencantumkan semua router virtual di mesh layanan yang ditentukan.  

```
aws appmesh list-virtual-routers \
    --mesh-name app1
```
Output:  

```
{
    "virtualRouters": [
        {
            "arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
            "meshName": "app1",
            "virtualRouterName": "vrServiceB"
        }
    ]
}
```
Untuk informasi selengkapnya, lihat [Router Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [ListVirtualRouters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-virtual-routers.html)di *Referensi AWS CLI Perintah*. 

### `list-virtual-services`
<a name="app-mesh_ListVirtualServices_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`list-virtual-services`.

**AWS CLI**  
**Untuk daftar layanan virtual**  
`list-virtual-services`Contoh berikut mencantumkan semua layanan virtual di mesh layanan yang ditentukan.  

```
aws appmesh list-virtual-services \
    --mesh-name app1
```
Output:  

```
{
    "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"
        }
    ]
}
```
Untuk informasi selengkapnya, lihat [Layanan Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [ListVirtualServices](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-virtual-services.html)di *Referensi AWS CLI Perintah*. 

### `tag-resource`
<a name="app-mesh_TagResource_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`tag-resource`.

**AWS CLI**  
**Untuk menandai sumber daya**  
`tag-resource`Contoh berikut menambahkan tag `key1` dengan nilai `value1` ke sumber daya yang ditentukan.  

```
aws appmesh tag-resource \
    --resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1 \
    --tags key=key1,value=value1
```
Perintah ini tidak menghasilkan output.  
+  Untuk detail API, lihat [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/tag-resource.html)di *Referensi AWS CLI Perintah*. 

### `untag-resource`
<a name="app-mesh_UntagResource_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`untag-resource`.

**AWS CLI**  
**Untuk menghapus tag sumber daya**  
`untag-resource`Contoh berikut menghapus tag dengan kunci `key1` dari sumber daya yang ditentukan.  

```
aws appmesh untag-resource \
    --resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1 \
    --tag-keys key1
```
Perintah ini tidak menghasilkan output.  
+  Untuk detail API, lihat [UntagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/untag-resource.html)di *Referensi AWS CLI Perintah*. 

### `update-mesh`
<a name="app-mesh_UpdateMesh_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`update-mesh`.

**AWS CLI**  
**Untuk memperbarui mesh layanan**  
`update-mesh`Contoh berikut menggunakan file input JSON untuk memperbarui mesh layanan untuk memungkinkan semua lalu lintas keluar eksternal diteruskan melalui proxy Envoy yang tidak tersentuh.  

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

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

```
{
    "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"
        }
    }
}
```
Untuk informasi selengkapnya, lihat [Service Meshes](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [UpdateMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-mesh.html)di *Referensi AWS CLI Perintah*. 

### `update-route`
<a name="app-mesh_UpdateRoute_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`update-route`.

**AWS CLI**  
**Untuk memperbarui rute**  
`update-route`Contoh berikut menggunakan file input JSON untuk memperbarui bobot untuk rute.  

```
aws appmesh update-route \
    --cli-input-json file://update-route-weighted.json
```
Isi dari `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"
}
```
Output:  

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Rute](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [UpdateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-route.html)di *Referensi AWS CLI Perintah*. 

### `update-virtual-node`
<a name="app-mesh_UpdateVirtualNode_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`update-virtual-node`.

**AWS CLI**  
**Untuk memperbarui node virtual**  
`update-virtual-node`Contoh berikut menggunakan file input JSON untuk menambahkan pemeriksaan kesehatan ke node virtual.  

```
aws appmesh update-virtual-node \
    --cli-input-json file://update-virtual-node.json
```
Isi dari `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"
}
```
Output:  

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Node Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [UpdateVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-virtual-node.html)di *Referensi AWS CLI Perintah*. 

### `update-virtual-router`
<a name="app-mesh_UpdateVirtualRouter_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`update-virtual-router`.

**AWS CLI**  
**Untuk memperbarui router virtual**  
`update-virtual-router`Contoh berikut menggunakan file input JSON untuk memperbarui port pendengar router virtual.  

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

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

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Router Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [UpdateVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-virtual-router.html)di *Referensi AWS CLI Perintah*. 

### `update-virtual-service`
<a name="app-mesh_UpdateVirtualService_cli_2_topic"></a>

Contoh kode berikut menunjukkan cara menggunakan`update-virtual-service`.

**AWS CLI**  
**Untuk memperbarui layanan virtual**  
`update-virtual-service`Contoh berikut menggunakan file input JSON untuk memperbarui layanan virtual untuk menggunakan penyedia router virtual.  

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

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

```
{
    "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"
    }
}
```
Untuk informasi selengkapnya, lihat [Layanan Virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) di *Panduan Pengguna AWS App Mesh*.  
+  Untuk detail API, lihat [UpdateVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-virtual-service.html)di *Referensi AWS CLI Perintah*.