Hay más ejemplos de AWS SDK disponibles en el GitHub repositorio de [ejemplos de AWS Doc SDK](https://github.com/awsdocs/aws-doc-sdk-examples).

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Ejemplos de API Gateway HTTP y WebSocket API que utilizan AWS CLI
<a name="cli_2_apigatewayv2_code_examples"></a>

Los siguientes ejemplos de código muestran cómo realizar acciones e implementar escenarios comunes mediante el AWS Command Line Interface uso de HTTP y WebSocket API API Gateway.

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 distintas funciones de servicio, 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.

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

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

### `create-api-mapping`
<a name="apigatewayv2_CreateApiMapping_cli_2_topic"></a>

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

**AWS CLI**  
**Creación de una asignación de API para una API**  
En el siguiente ejemplo de `create-api-mapping`, se asigna la etapa `test` de una API a la ruta `/myApi` del nombre de dominio personalizado `regional.example.com`.  

```
aws apigatewayv2 create-api-mapping \
    --domain-name regional.example.com \
    --api-mapping-key myApi \
    --api-id a1b2c3d4 \
    --stage test
```
Salida:  

```
{
    "ApiId": "a1b2c3d4",
    "ApiMappingId": "0qzs2sy7bh",
    "ApiMappingKey": "myApi"
    "Stage": "test"
}
```
Para obtener más información, consulte [Configuración de un nombre de dominio personalizado regional en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [CreateApiMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-api-mapping.html)la *Referencia de AWS CLI comandos*. 

### `create-api`
<a name="apigatewayv2_CreateApi_cli_2_topic"></a>

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

**AWS CLI**  
**Cómo crear una API de HTTP**  
En el siguiente ejemplo de `create-api`, se crea una API de HTTP mediante la creación rápida. Puede usar Quick Create para crear una API con una integración AWS Lambda o HTTP, una ruta global predeterminada y una etapa predeterminada que esté configurada para implementar cambios automáticamente. El siguiente comando utiliza la creación rápida para crear una API de HTTP que se integra con una función de Lambda.  

```
aws apigatewayv2 create-api \
    --name my-http-api \
    --protocol-type HTTP \
    --target arn:aws:lambda:us-west-2:123456789012:function:my-lambda-function
```
Salida:  

```
{
    "ApiEndpoint": "https://a1b2c3d4.execute-api.us-west-2.amazonaws.com",
    "ApiId": "a1b2c3d4",
    "ApiKeySelectionExpression": "$request.header.x-api-key",
    "CreatedDate": "2020-04-08T19:05:45+00:00",
    "Name": "my-http-api",
    "ProtocolType": "HTTP",
    "RouteSelectionExpression": "$request.method $request.path"
}
```
Para obtener más información, consulte [Desarrollo de las API de HTTP en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
**Para crear una API WebSocket **  
En el siguiente `create-api` ejemplo, se crea una WebSocket API con el nombre especificado.  

```
aws apigatewayv2 create-api \
    --name "myWebSocketApi" \
    --protocol-type WEBSOCKET \
    --route-selection-expression '$request.body.action'
```
Salida:  

```
{
    "ApiKeySelectionExpression": "$request.header.x-api-key",
    "Name": "myWebSocketApi",
    "CreatedDate": "2018-11-15T06:23:51Z",
    "ProtocolType": "WEBSOCKET",
    "RouteSelectionExpression": "'$request.body.action'",
    "ApiId": "aabbccddee"
}
```
Para obtener más información, consulte [Crear una WebSocket API en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-create-empty-api.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [CreateApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-api.html)la *Referencia de AWS CLI comandos*. 

### `create-authorizer`
<a name="apigatewayv2_CreateAuthorizer_cli_2_topic"></a>

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

**AWS CLI**  
**Creación de un autorizador de JWT para una API de HTTP**  
En el siguiente ejemplo de `create-authorizer`, se crea un autorizador de JWT que utiliza Amazon Cognito como un proveedor de identidades.  

```
aws apigatewayv2 create-authorizer \
    --name my-jwt-authorizer \
    --api-id a1b2c3d4 \
    --authorizer-type JWT \
    --identity-source '$request.header.Authorization' \
    --jwt-configuration Audience=123456abc,Issuer=https://cognito-idp.us-west-2.amazonaws.com/us-west-2_abc123
```
Salida:  

```
{
    "AuthorizerId": "a1b2c3",
    "AuthorizerType": "JWT",
    "IdentitySource": [
        "$request.header.Authorization"
    ],
    "JwtConfiguration": {
        "Audience": [
            "123456abc"
        ],
        "Issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_abc123"
    },
    "Name": "my-jwt-authorizer"
}
```
Para obtener más información, consulte [Control del acceso a HTTP APIs con autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) en la Guía para *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte la Referencia [CreateAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-authorizer.html)de *AWS CLI comandos*. 

### `create-deployment`
<a name="apigatewayv2_CreateDeployment_cli_2_topic"></a>

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

**AWS CLI**  
**Creación de una implementación para una API**  
En el siguiente ejemplo de `create-deployment`, se crea una implementación para una API y se asocia dicha implementación con la etapa `dev` de la API.  

```
aws apigatewayv2 create-deployment \
    --api-id a1b2c3d4 \
    --stage-name dev
```
Salida:  

```
{
    "AutoDeployed": false,
    "CreatedDate": "2020-04-06T23:38:08Z",
    "DeploymentId": "53lz9l",
    "DeploymentStatus": "DEPLOYED"
}
```
Para obtener más información, consulte [Implementación de API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-basic-concept.html#apigateway-definition-api-deployment) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [CreateDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-deployment.html)la *Referencia de AWS CLI comandos*. 

### `create-domain-name`
<a name="apigatewayv2_CreateDomainName_cli_2_topic"></a>

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

**AWS CLI**  
**Creación de un nombre de dominio personalizado**  
En el siguiente ejemplo de `create-domain-name`, se crea un nombre de dominio personalizado regional para una API.  

```
aws apigatewayv2 create-domain-name \
    --domain-name regional.example.com \
    --domain-name-configurations CertificateArn=arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678
```
Salida:  

```
{
    "ApiMappingSelectionExpression": "$request.basepath",
    "DomainName": "regional.example.com",
    "DomainNameConfigurations": [
        {
            "ApiGatewayDomainName": "d-id.execute-api.us-west-2.amazonaws.com",
            "CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678",
            "EndpointType": "REGIONAL",
            "HostedZoneId": "123456789111",
            "SecurityPolicy": "TLS_1_2",
            "DomainNameStatus": "AVAILABLE"
        }
    ]
}
```
Para obtener más información, consulte [Configuración de un nombre de dominio personalizado regional en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [CreateDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-domain-name.html)la *Referencia de AWS CLI comandos*. 

### `create-integration`
<a name="apigatewayv2_CreateIntegration_cli_2_topic"></a>

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

**AWS CLI**  
**Para crear una integración WebSocket de API**  
El siguiente `create-integration` ejemplo crea una integración simulada para una WebSocket API.  

```
aws apigatewayv2 create-integration \
    --api-id aabbccddee \
    --passthrough-behavior WHEN_NO_MATCH \
    --timeout-in-millis 29000 \
    --connection-type INTERNET \
    --integration-type MOCK
```
Salida:  

```
{
    "ConnectionType": "INTERNET",
    "IntegrationId": "0abcdef",
    "IntegrationResponseSelectionExpression": "${integration.response.statuscode}",
    "IntegrationType": "MOCK",
    "PassthroughBehavior": "WHEN_NO_MATCH",
    "PayloadFormatVersion": "1.0",
    "TimeoutInMillis": 29000
}
```
Para obtener más información, consulte [Configurar una solicitud de integración de WebSocket API en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-integration-requests.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
**Creación de una integración de API de HTTP**  
El siguiente `create-integration` ejemplo crea una integración de AWS Lambda para una API HTTP.  

```
aws apigatewayv2 create-integration \
    --api-id a1b2c3d4 \
    --integration-type AWS_PROXY \
    --integration-uri arn:aws:lambda:us-west-2:123456789012:function:my-function \
    --payload-format-version 2.0
```
Salida:  

```
{
    "ConnectionType": "INTERNET",
    "IntegrationId": "0abcdef",
    "IntegrationMethod": "POST",
    "IntegrationType": "AWS_PROXY",
    "IntegrationUri": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
    "PayloadFormatVersion": "2.0",
    "TimeoutInMillis": 30000
}
```
Para obtener más información, consulte [Configuración de integraciones para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [CreateIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-integration.html)la *Referencia de AWS CLI comandos*. 

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

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

**AWS CLI**  
**Para crear una ruta \$1default para una API WebSocket o HTTP**  
En el siguiente `create-route` ejemplo, se crea una `$default` ruta para una API HTTP WebSocket o una API.  

```
aws apigatewayv2 create-route \
    --api-id aabbccddee \
    --route-key '$default'
```
Salida:  

```
{
    "ApiKeyRequired": false,
    "AuthorizationType": "NONE",
    "RouteKey": "$default",
    "RouteId": "1122334"
}
```
Para obtener más información, consulte [Cómo trabajar con rutas WebSocket APIs en la Guía para](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-add-route.html) *desarrolladores de Amazon API Gateway*  
**Creación de una ruta para una API de HTTP**  
En el siguiente ejemplo de `create-route`, se crea una ruta con el nombre `signup` que acepta solicitudes POST.  

```
aws apigatewayv2 create-route \
    --api-id aabbccddee \
    --route-key 'POST /signup'
```
Salida:  

```
{
    "ApiKeyRequired": false,
    "AuthorizationType": "NONE",
    "RouteKey": "POST /signup",
    "RouteId": "1122334"
}
```
Para obtener más información, consulte [Trabajar con rutas para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-routes.html) en la *Guía para desarrolladores de Amazon API Gateway*  
+  Para obtener más información sobre la API, consulte [CreateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-route.html)la *Referencia de AWS CLI comandos*. 

### `create-routing-rule`
<a name="apigatewayv2_CreateRoutingRule_cli_2_topic"></a>

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

**AWS CLI**  
**Creación de una regla de enrutamiento**  
El siguiente ejemplo de `create-routing-rule` crea una regla de enrutamiento con una prioridad de `50`.  

```
aws apigatewayv2 create-routing-rule \
    --domain-name 'regional.example.com' \
    --priority 50 \
    --conditions '[ \
        { \
            "MatchBasePaths": { \
                "AnyOf": [ \
                    "PetStoreShopper" \
                ] \
            } \
        } \
    ]' \
    --actions '[ \
        { \
            "InvokeApi": { \
                "ApiId": "abcd1234", \
                "Stage": "prod" \
            } \
        } \
    ]'
```
Salida:  

```
{
    "Actions": [
        {
            "InvokeApi": {
                "ApiId": "abcd1234",
                "Stage": "prod",
                "StripBasePath": false
            }
        }
    ],
    "Conditions": [
        {
            "MatchBasePaths": {
                "AnyOf": [
                    "PetStoreShopper"
                ]
            }
        }
    ],
    "Priority": 50,
    "RoutingRuleArn": "arn:aws:apigateway:us-east-2:123456789012:/domainnames/regional.example.com/routingrules/aaa111",
    "RoutingRuleId": "aaa111"
}
```
Para obtener más información, consulte [Reglas de enrutamiento para conectar las etapas de la API a un nombre de dominio personalizado para REST APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-routing-rules.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [CreateRoutingRule](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-routing-rule.html)la *Referencia de AWS CLI comandos*. 

### `create-stage`
<a name="apigatewayv2_CreateStage_cli_2_topic"></a>

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

**AWS CLI**  
**Creación de una etapa**  
En el siguiente ejemplo de `create-stage`, se crea una etapa denominada dev para una API.  

```
aws apigatewayv2 create-stage \
    --api-id a1b2c3d4 \
    --stage-name dev
```
Salida:  

```
{
    "CreatedDate": "2020-04-06T23:23:46Z",
    "DefaultRouteSettings": {
        "DetailedMetricsEnabled": false
    },
    "LastUpdatedDate": "2020-04-06T23:23:46Z",
    "RouteSettings": {},
    "StageName": "dev",
    "StageVariables": {},
    "Tags": {}
}
```
Para obtener más información, consulte [Trabajar con etapas para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-stages.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [CreateStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-stage.html)la *Referencia de AWS CLI comandos*. 

### `create-vpc-link`
<a name="apigatewayv2_CreateVpcLink_cli_2_topic"></a>

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

**AWS CLI**  
**Creación de un enlace de VPC para una API de HTTP**  
En el siguiente `create-vpc-link` ejemplo, se crea un enlace de VPC para HTTP. APIs  

```
aws apigatewayv2 create-vpc-link \
    --name MyVpcLink \
    --subnet-ids subnet-aaaa subnet-bbbb \
    --security-group-ids sg1234 sg5678
```
Salida:  

```
{
    "CreatedDate": "2020-04-07T00:11:46Z",
    "Name": "MyVpcLink",
    "SecurityGroupIds": [
        "sg1234",
        "sg5678"
    ],
    "SubnetIds": [
        "subnet-aaaa",
        "subnet-bbbb"
    ],
    "Tags": {},
    "VpcLinkId": "abcd123",
    "VpcLinkStatus": "PENDING",
    "VpcLinkStatusMessage": "VPC link is provisioning ENIs",
    "VpcLinkVersion": "V2"
}
```
Para obtener más información, consulte [Uso de enlaces de VPC para HTTP APIs en la Guía para](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vpc-links.html) *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [CreateVpcLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-vpc-link.html)la *Referencia de AWS CLI comandos*. 

### `delete-access-log-settings`
<a name="apigatewayv2_DeleteAccessLogSettings_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `delete-access-log-settings`.

**AWS CLI**  
**Deshabiltación del registro de acceso de una API**  
En el siguiente ejemplo de `delete-access-log-settings`, se elimina la configuración de registro de acceso de la etapa `$default` de una API. Para deshabilitar el registro de acceso de una etapa, elimine su configuración de registro de acceso.  

```
aws apigatewayv2 delete-access-log-settings \
    --api-id a1b2c3d4 \
    --stage-name '$default'
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Configuración del registro de las API de HTTP en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [DeleteAccessLogSettings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-access-log-settings.html)la *Referencia de AWS CLI comandos*. 

### `delete-api-mapping`
<a name="apigatewayv2_DeleteApiMapping_cli_2_topic"></a>

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

**AWS CLI**  
**Eliminación de una asignación de API**  
En el siguiente ejemplo de `delete-api-mapping`, se elimina una asignación de API del nombre de dominio personalizado `api.example.com`.  

```
aws apigatewayv2 delete-api-mapping \
    --api-mapping-id a1b2c3 \
    --domain-name api.example.com
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Configuración de un nombre de dominio personalizado regional en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [DeleteApiMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-api-mapping.html)la *Referencia de AWS CLI comandos*. 

### `delete-api`
<a name="apigatewayv2_DeleteApi_cli_2_topic"></a>

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

**AWS CLI**  
**Eliminación de una API**  
En el siguiente ejemplo de `delete-api`, se elimina una API.  

```
aws apigatewayv2 delete-api \
    --api-id a1b2c3d4
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Trabajar con HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html) y [Trabajar con WebSocket APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [DeleteApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-api.html)la *Referencia de AWS CLI comandos*. 

### `delete-authorizer`
<a name="apigatewayv2_DeleteAuthorizer_cli_2_topic"></a>

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

**AWS CLI**  
**Eliminación de un autorizador**  
En el siguiente ejemplo de `delete-authorizer`, se elimina un autorizador.  

```
aws apigatewayv2 delete-authorizer \
    --api-id a1b2c3d4 \
    --authorizer-id a1b2c3
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Control del acceso a HTTP APIs con autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) en la Guía para *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte la Referencia [DeleteAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-authorizer.html)de *AWS CLI comandos*. 

### `delete-cors-configuration`
<a name="apigatewayv2_DeleteCorsConfiguration_cli_2_topic"></a>

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

**AWS CLI**  
**Eliminación de la configuración de CORS para una API de HTTP**  
En el siguiente ejemplo de `delete-cors-configuration`, se deshabilita CORS para una API de HTTP mediante la eliminación de su configuración de CORS.  

```
aws apigatewayv2 delete-cors-configuration \
    --api-id a1b2c3d4
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Configuración de CORS de las API de HTTP en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-cors.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [DeleteCorsConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-cors-configuration.html)la *Referencia de AWS CLI comandos*. 

### `delete-deployment`
<a name="apigatewayv2_DeleteDeployment_cli_2_topic"></a>

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

**AWS CLI**  
**Eliminación de una implementación**  
En el siguiente ejemplo de `delete-deployment`, se elimina una implementación de una API.  

```
aws apigatewayv2 delete-deployment \
    --api-id a1b2c3d4 \
    --deployment-id a1b2c3
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Implementación de API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-basic-concept.html#apigateway-definition-api-deployment) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [DeleteDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-deployment.html)la *Referencia de AWS CLI comandos*. 

### `delete-domain-name`
<a name="apigatewayv2_DeleteDomainName_cli_2_topic"></a>

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

**AWS CLI**  
**Eliminación de un nombre de dominio personalizado**  
En el siguiente ejemplo de `delete-domain-name`, se elimina un nombre de dominio personalizado.  

```
aws apigatewayv2 delete-domain-name \
    --domain-name api.example.com
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Configuración de un nombre de dominio personalizado regional en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [DeleteDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-domain-name.html)la *Referencia de AWS CLI comandos*. 

### `delete-integration`
<a name="apigatewayv2_DeleteIntegration_cli_2_topic"></a>

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

**AWS CLI**  
**Eliminación de una integración**  
En el siguiente ejemplo de `delete-integration`, se elimina una integración de API.  

```
aws apigatewayv2 delete-integration \
    --api-id a1b2c3d4 \
    --integration-id a1b2c3
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Configuración de integraciones para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations.html) y [Configuración de integraciones de WebSocket API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-integrations.html) en la Guía para *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte la Referencia [DeleteIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-integration.html)de *AWS CLI comandos*. 

### `delete-route-settings`
<a name="apigatewayv2_DeleteRouteSettings_cli_2_topic"></a>

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

**AWS CLI**  
**Eliminación de una configuración de ruta**  
En el siguiente ejemplo de `delete-route-settings`, se elimina la configuración de la ruta especificada.  

```
aws apigatewayv2 delete-route-settings \
    --api-id a1b2c3d4 \
    --stage-name dev \
    --route-key 'GET /pets'
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Trabajar con rutas para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-routes.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [DeleteRouteSettings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-route-settings.html)la *Referencia de AWS CLI comandos*. 

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

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 una ruta de API.  

```
aws apigatewayv2 delete-route \
    --api-id a1b2c3d4 \
    --route-id a1b2c3
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Trabajar con rutas para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-routes.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [DeleteRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-route.html)la *Referencia de AWS CLI comandos*. 

### `delete-routing-rule`
<a name="apigatewayv2_DeleteRoutingRule_cli_2_topic"></a>

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

**AWS CLI**  
**Eliminación de una regla de enrutamiento**  
En el siguiente ejemplo de `delete-routing-rule`, se elimina una regla de enrutamiento para un nombre de dominio personalizado.  

```
aws apigatewayv2 delete-routing-rule \
    --domain-name 'regional.example.com' \
    --routing-rule-id aaa111
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Reglas de enrutamiento para conectar las etapas de la API a un nombre de dominio personalizado para REST APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-routing-rules.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [DeleteRoutingRule](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-routing-rule.html)la *Referencia de AWS CLI comandos*. 

### `delete-stage`
<a name="apigatewayv2_DeleteStage_cli_2_topic"></a>

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

**AWS CLI**  
**Para eliminar un escenario**  
En el siguiente ejemplo de `delete-stage`, se elimina la etapa `test` de una API.  

```
aws apigatewayv2 delete-stage \
    --api-id a1b2c3d4 \
    --stage-name test
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Trabajar con etapas para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-stages.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [DeleteStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-stage.html)la *Referencia de AWS CLI comandos*. 

### `delete-vpc-link`
<a name="apigatewayv2_DeleteVpcLink_cli_2_topic"></a>

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

**AWS CLI**  
**Eliminación de un enlace de VPC para una API de HTTP**  
En el siguiente ejemplo de `delete-vpc-link` se elimina un enlace de VPC.  

```
aws apigatewayv2 delete-vpc-link \
    --vpc-link-id abcd123
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Uso de enlaces de VPC para HTTP APIs en la Guía para](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vpc-links.html) *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [DeleteVpcLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-vpc-link.html)la *Referencia de AWS CLI comandos*. 

### `export-api`
<a name="apigatewayv2_ExportApi_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `export-api`.

**AWS CLI**  
**Exportación de una definición de OpenAPI de una API de HTTP**  
En el siguiente ejemplo de `export-api`, se exporta una definición de OpenAPI 3.0 de una etapa de API denominada `prod` a un archivo YAML denominado `stage-definition.yaml`. El archivo de definición exportado incluye extensiones de API Gateway de forma predeterminada.  

```
aws apigatewayv2 export-api \
    --api-id a1b2c3d4 \
    --output-type YAML \
    --specification OAS30 \
    --stage-name prod \
    stage-definition.yaml
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Exportación de las API de HTTP desde API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-export.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [ExportApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/export-api.html)la *Referencia de AWS CLI comandos*. 

### `get-api-mapping`
<a name="apigatewayv2_GetApiMapping_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-api-mapping`.

**AWS CLI**  
**Para obtener información acerca de una asignación de API de un nombre de dominio personalizado**  
En el siguiente ejemplo de `get-api-mapping`, se muestra información sobre una asignación de API del nombre de dominio personalizado `api.example.com`.  

```
aws apigatewayv2 get-api-mapping \
    --api-mapping-id a1b2c3 \
    --domain-name api.example.com
```
Salida:  

```
{
    "ApiId": "a1b2c3d4",
    "ApiMappingId": "a1b2c3d5",
    "ApiMappingKey": "myTestApi"
    "Stage": "test"
}
```
Para obtener más información, consulte [Configuración de un nombre de dominio personalizado regional en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetApiMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-api-mapping.html)la *Referencia de AWS CLI comandos*. 

### `get-api-mappings`
<a name="apigatewayv2_GetApiMappings_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-api-mappings`.

**AWS CLI**  
**Para obtener las asignaciones de API de un nombre de dominio personalizado**  
En el siguiente ejemplo de `get-api-mappings`, se muestra una lista de todas las asignaciones de API del nombre de dominio personalizado `api.example.com`.  

```
aws apigatewayv2 get-api-mappings \
    --domain-name api.example.com
```
Salida:  

```
{
    "Items": [
        {
            "ApiId": "a1b2c3d4",
            "ApiMappingId": "a1b2c3d5",
            "ApiMappingKey": "myTestApi"
            "Stage": "test"
        },
        {
            "ApiId": "a5b6c7d8",
            "ApiMappingId": "a1b2c3d6",
            "ApiMappingKey": "myDevApi"
            "Stage": "dev"
        },
    ]
}
```
Para obtener más información, consulte [Configuración de un nombre de dominio personalizado regional en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetApiMappings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-api-mappings.html)la *Referencia de AWS CLI comandos*. 

### `get-api`
<a name="apigatewayv2_GetApi_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-api`.

**AWS CLI**  
**Recuperación de información sobre una API**  
En el siguiente ejemplo de `get-api`, se muestra información acerca de una API.  

```
aws apigatewayv2 get-api \
    --api-id a1b2c3d4
```
Salida:  

```
{
    "ApiEndpoint": "https://a1b2c3d4.execute-api.us-west-2.amazonaws.com",
    "ApiId": "a1b2c3d4",
    "ApiKeySelectionExpression": "$request.header.x-api-key",
    "CreatedDate": "2020-03-28T00:32:37Z",
    "Name": "my-api",
    "ProtocolType": "HTTP",
    "RouteSelectionExpression": "$request.method $request.path",
    "Tags": {
        "department": "finance"
    }
}
```
+  Para obtener más información sobre la API, consulte [GetApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-api.html)la *Referencia de AWS CLI comandos*. 

### `get-apis`
<a name="apigatewayv2_GetApis_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-apis`.

**AWS CLI**  
**Para recuperar una lista de APIs**  
En el siguiente `get-apis` ejemplo, se enumeran todos APIs los del usuario actual.  

```
aws apigatewayv2 get-apis
```
Salida:  

```
{
    "Items": [
        {
            "ApiEndpoint": "wss://a1b2c3d4.execute-api.us-west-2.amazonaws.com",
            "ApiId": "a1b2c3d4",
            "ApiKeySelectionExpression": "$request.header.x-api-key",
            "CreatedDate": "2020-04-07T20:21:59Z",
            "Name": "my-websocket-api",
            "ProtocolType": "WEBSOCKET",
            "RouteSelectionExpression": "$request.body.message",
            "Tags": {}
        },
        {
            "ApiEndpoint": "https://a1b2c3d5.execute-api.us-west-2.amazonaws.com",
            "ApiId": "a1b2c3d5",
            "ApiKeySelectionExpression": "$request.header.x-api-key",
            "CreatedDate": "2020-04-07T20:23:50Z",
            "Name": "my-http-api",
            "ProtocolType": "HTTP",
            "RouteSelectionExpression": "$request.method $request.path",
            "Tags": {}
        }
    ]
}
```
Para obtener más información, consulte [Trabajar con HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html) y [Trabajar con WebSocket APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetApis](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-apis.html)la *Referencia de AWS CLI comandos*. 

### `get-authorizer`
<a name="apigatewayv2_GetAuthorizer_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-authorizer`.

**AWS CLI**  
**Recuperación de información sobre un autorizador**  
En el siguiente ejemplo de `get-authorizer`, se muestra información acerca de un autorizador.  

```
aws apigatewayv2 get-authorizer \
    --api-id a1b2c3d4 \
    --authorizer-id a1b2c3
```
Salida:  

```
{
    "AuthorizerId": "a1b2c3",
    "AuthorizerType": "JWT",
    "IdentitySource": [
        "$request.header.Authorization"
    ],
    "JwtConfiguration": {
        "Audience": [
            "123456abc"
        ],
        "Issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_abc123"
    },
    "Name": "my-jwt-authorizer"
}
```
Para obtener más información, consulte [Control del acceso a HTTP APIs con autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) en la Guía para *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte la Referencia [GetAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-authorizer.html)de *AWS CLI comandos*. 

### `get-authorizers`
<a name="apigatewayv2_GetAuthorizers_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-authorizers`.

**AWS CLI**  
**Recuperación de una lista de autorizadores de una API**  
En el siguiente ejemplo de `get-authorizers`, se muestra una lista de todos los autorizadores de una API.  

```
aws apigatewayv2 get-authorizers \
    --api-id a1b2c3d4
```
Salida:  

```
{
    "Items": [
        {
            "AuthorizerId": "a1b2c3",
            "AuthorizerType": "JWT",
            "IdentitySource": [
                "$request.header.Authorization"
            ],
            "JwtConfiguration": {
                "Audience": [
                    "123456abc"
                ],
                "Issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_abc123"
            },
            "Name": "my-jwt-authorizer"
        },
        {
            "AuthorizerId": "a1b2c4",
            "AuthorizerType": "JWT",
            "IdentitySource": [
                "$request.header.Authorization"
            ],
            "JwtConfiguration": {
                "Audience": [
                    "6789abcde"
                ],
                "Issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_abc234"
            },
            "Name": "new-jwt-authorizer"
        }
    ]
}
```
Para obtener más información, consulte [Control del acceso a HTTP APIs con autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) en la Guía para *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte la Referencia [GetAuthorizers](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-authorizers.html)de *AWS CLI comandos*. 

### `get-deployment`
<a name="apigatewayv2_GetDeployment_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-deployment`.

**AWS CLI**  
**Recuperación de información acerca de una implementación**  
En el siguiente ejemplo de `get-deployment`, se muestra información acerca de una implementación.  

```
aws apigatewayv2 get-deployment \
    --api-id a1b2c3d4 \
    --deployment-id abcdef
```
Salida:  

```
{
    "AutoDeployed": true,
    "CreatedDate": "2020-04-07T23:58:40Z",
    "DeploymentId": "abcdef",
    "DeploymentStatus": "DEPLOYED",
    "Description": "Automatic deployment triggered by changes to the Api configuration"
}
```
Para obtener más información, consulte [Implementación de API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-basic-concept.html#apigateway-definition-api-deployment) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-deployment.html)la *Referencia de AWS CLI comandos*. 

### `get-deployments`
<a name="apigatewayv2_GetDeployments_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-deployments`.

**AWS CLI**  
**Recuperación de una lista de implementaciones**  
En el siguiente ejemplo de `get-deployments`, se muestra una lista de todas las implementaciones de una API.  

```
aws apigatewayv2 get-deployments \
    --api-id a1b2c3d4
```
Salida:  

```
{
    "Items": [
        {
            "AutoDeployed": true,
            "CreatedDate": "2020-04-07T23:58:40Z",
            "DeploymentId": "abcdef",
            "DeploymentStatus": "DEPLOYED",
            "Description": "Automatic deployment triggered by changes to the Api configuration"
        },
        {
            "AutoDeployed": true,
            "CreatedDate": "2020-04-06T00:33:00Z",
            "DeploymentId": "bcdefg",
            "DeploymentStatus": "DEPLOYED",
            "Description": "Automatic deployment triggered by changes to the Api configuration"
        }
    ]
}
```
Para obtener más información, consulte [Implementación de API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-basic-concept.html#apigateway-definition-api-deployment) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetDeployments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-deployments.html)la *Referencia de AWS CLI comandos*. 

### `get-domain-name`
<a name="apigatewayv2_GetDomainName_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-domain-name`.

**AWS CLI**  
**Recuperación de información acerca de un nombre de dominio personalizado**  
En el siguiente ejemplo de `get-domain-name`, se muestra información sobre un nombre de dominio personalizado.  

```
aws apigatewayv2 get-domain-name \
    --domain-name api.example.com
```
Salida:  

```
{
    "ApiMappingSelectionExpression": "$request.basepath",
    "DomainName": "api.example.com",
    "DomainNameConfigurations": [
        {
            "ApiGatewayDomainName": "d-1234.execute-api.us-west-2.amazonaws.com",
            "CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678",
            "EndpointType": "REGIONAL",
            "HostedZoneId": "123456789111",
            "SecurityPolicy": "TLS_1_2",
            "DomainNameStatus": "AVAILABLE"
        }
    ],
    "Tags": {}
}
```
Para obtener más información, consulte [Configuración de un nombre de dominio personalizado regional en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-domain-name.html)la *Referencia de AWS CLI comandos*. 

### `get-domain-names`
<a name="apigatewayv2_GetDomainNames_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-domain-names`.

**AWS CLI**  
**Recuperación de una lista de nombres de dominio personalizados**  
En el siguiente ejemplo de `get-domain-names`, se muestra una lista de todos los nombres de dominio personalizados del usuario actual.  

```
aws apigatewayv2 get-domain-names
```
Salida:  

```
{
    "Items": [
        {
            "ApiMappingSelectionExpression": "$request.basepath",
            "DomainName": "api.example.com",
            "DomainNameConfigurations": [
                {
                    "ApiGatewayDomainName": "d-1234.execute-api.us-west-2.amazonaws.com",
                    "CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678",
                    "EndpointType": "REGIONAL",
                    "HostedZoneId": "123456789111",
                    "SecurityPolicy": "TLS_1_2",
                    "DomainNameStatus": "AVAILABLE"
                }
            ]
        },
        {
            "ApiMappingSelectionExpression": "$request.basepath",
            "DomainName": "newApi.example.com",
            "DomainNameConfigurations": [
                {
                    "ApiGatewayDomainName": "d-5678.execute-api.us-west-2.amazonaws.com",
                    "CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678",
                    "EndpointType": "REGIONAL",
                    "HostedZoneId": "123456789222",
                    "SecurityPolicy": "TLS_1_2",
                    "DomainNameStatus": "AVAILABLE"
                }
            ]
        }
    ]
}
```
Para obtener más información, consulte [Configuración de un nombre de dominio personalizado regional en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetDomainNames](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-domain-names.html)la *Referencia de AWS CLI comandos*. 

### `get-integration`
<a name="apigatewayv2_GetIntegration_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-integration`.

**AWS CLI**  
**Recuperación de información acerca de una integración**  
En el siguiente ejemplo de `get-integration`, se muestra información acerca de una integración.  

```
aws apigatewayv2 get-integration \
    --api-id a1b2c3d4 \
    --integration-id a1b2c3
```
Salida:  

```
{
    "ApiGatewayManaged": true,
    "ConnectionType": "INTERNET",
    "IntegrationId": "a1b2c3",
    "IntegrationMethod": "POST",
    "IntegrationType": "AWS_PROXY",
    "IntegrationUri": "arn:aws:lambda:us-west-2:12356789012:function:hello12",
    "PayloadFormatVersion": "2.0",
    "TimeoutInMillis": 30000
}
```
Para obtener más información, consulte [Configuración de integraciones para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations.html) y [Configuración de integraciones de WebSocket API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-integrations.html) en la Guía para *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte la Referencia [GetIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-integration.html)de *AWS CLI comandos*. 

### `get-integrations`
<a name="apigatewayv2_GetIntegrations_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-integrations`.

**AWS CLI**  
**Recuperación de una lista de integraciones**  
En el siguiente ejemplo de `get-integrations`, se muestra una lista de todas las integraciones de una API.  

```
aws apigatewayv2 get-integrations \
    --api-id a1b2c3d4
```
Salida:  

```
{
    "Items": [
        {
            "ApiGatewayManaged": true,
            "ConnectionType": "INTERNET",
            "IntegrationId": "a1b2c3",
            "IntegrationMethod": "POST",
            "IntegrationType": "AWS_PROXY",
            "IntegrationUri": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
            "PayloadFormatVersion": "2.0",
            "TimeoutInMillis": 30000
        },
        {
            "ConnectionType": "INTERNET",
            "IntegrationId": "a1b2c4",
            "IntegrationMethod": "ANY",
            "IntegrationType": "HTTP_PROXY",
            "IntegrationUri": "https://www.example.com",
            "PayloadFormatVersion": "1.0",
            "TimeoutInMillis": 30000
        }
    ]
}
```
Para obtener más información, consulte [Configuración de integraciones para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations.html) y [Configuración de integraciones de WebSocket API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-integrations.html) en la Guía para *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte la Referencia [GetIntegrations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-integrations.html)de *AWS CLI comandos*. 

### `get-route`
<a name="apigatewayv2_GetRoute_cli_2_topic"></a>

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

**AWS CLI**  
**Recuperación de información sobre una ruta**  
En el siguiente ejemplo de `get-route`, se muestra información acerca de una ruta.  

```
aws apigatewayv2 get-route \
    --api-id a1b2c3d4 \
    --route-id 72jz1wk
```
Salida:  

```
{
    "ApiKeyRequired": false,
    "AuthorizationType": "NONE",
    "RouteId": "72jz1wk",
    "RouteKey": "ANY /pets",
    "Target": "integrations/a1b2c3"
}
```
Para obtener más información, consulte [Trabajar con rutas para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-routes.html) en la *Guía para desarrolladores de Amazon API Gateway*  
+  Para obtener más información sobre la API, consulte [GetRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-route.html)la *Referencia de AWS CLI comandos*. 

### `get-routes`
<a name="apigatewayv2_GetRoutes_cli_2_topic"></a>

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

**AWS CLI**  
**Recuperación de una lista de rutas**  
En el siguiente ejemplo de `get-routes`, se muestra una lista de todas las rutas de una API.  

```
aws apigatewayv2 get-routes \
    --api-id a1b2c3d4
```
Salida:  

```
{
    "Items": [
        {
            "ApiKeyRequired": false,
            "AuthorizationType": "NONE",
            "RouteId": "72jz1wk",
            "RouteKey": "ANY /admin",
            "Target": "integrations/a1b2c3"
        },
        {
            "ApiGatewayManaged": true,
            "ApiKeyRequired": false,
            "AuthorizationType": "NONE",
            "RouteId": "go65gqi",
            "RouteKey": "$default",
            "Target": "integrations/a1b2c4"
        }
    ]
}
```
Para obtener más información, consulte [Trabajar con rutas para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-routes.html) en la *Guía para desarrolladores de Amazon API Gateway*  
+  Para obtener más información sobre la API, consulte [GetRoutes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-routes.html)la *Referencia de AWS CLI comandos*. 

### `get-routing-rule`
<a name="apigatewayv2_GetRoutingRule_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-routing-rule`.

**AWS CLI**  
**Obtención de una regla de enrutamiento**  
En el siguiente ejemplo de `get-routing-rule`, se obtiene una regla de enrutamiento para un nombre de dominio.  

```
aws apigatewayv2 get-routing-rule \
    --domain-name 'regional.example.com' \
    --routing-rule-id aaa111
```
Salida:  

```
{
    "Actions": [
        {
            "InvokeApi": {
                "ApiId": "abcd1234",
                "Stage": "prod",
                "StripBasePath": false
            }
        }
    ],
    "Conditions": [
        {
            "MatchBasePaths": {
                "AnyOf": [
                    "PetStoreShopper"
                ]
            }
        }
    ],
    "Priority": 50,
    "RoutingRuleArn": "arn:aws:apigateway:us-east-2:123456789012:/domainnames/regional.example.com/routingrules/aaa111",
    "RoutingRuleId": "aaa111"
}
```
Para obtener más información, consulte [Reglas de enrutamiento para conectar las etapas de la API a un nombre de dominio personalizado para REST APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-routing-rules.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetRoutingRule](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-routing-rule.html)la *Referencia de AWS CLI comandos*. 

### `get-stage`
<a name="apigatewayv2_GetStage_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-stage`.

**AWS CLI**  
**Recuperación de información sobre una etapa**  
En el siguiente ejemplo de `get-stage`, se muestra información acerca de la etapa `prod` de una API.  

```
aws apigatewayv2 get-stage \
    --api-id a1b2c3d4 \
    --stage-name prod
```
Salida:  

```
{
    "CreatedDate": "2020-04-08T00:36:05Z",
    "DefaultRouteSettings": {
        "DetailedMetricsEnabled": false
    },
    "DeploymentId": "x1zwyv",
    "LastUpdatedDate": "2020-04-08T00:36:13Z",
    "RouteSettings": {},
    "StageName": "prod",
    "StageVariables": {
        "function": "my-prod-function"
    },
    "Tags": {}
}
```
Para obtener más información, consulte [Trabajar con etapas para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-stages.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-stage.html)la *Referencia de AWS CLI comandos*. 

### `get-stages`
<a name="apigatewayv2_GetStages_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-stages`.

**AWS CLI**  
**Recuperación de una lista de etapas**  
En el siguiente ejemplo de `get-stages`, se genera una lista de todas las etapas de una API.  

```
aws apigatewayv2 get-stages \
    --api-id a1b2c3d4
```
Salida:  

```
{
    "Items": [
        {
            "ApiGatewayManaged": true,
            "AutoDeploy": true,
            "CreatedDate": "2020-04-08T00:08:44Z",
            "DefaultRouteSettings": {
                "DetailedMetricsEnabled": false
            },
            "DeploymentId": "dty748",
            "LastDeploymentStatusMessage": "Successfully deployed stage with deployment ID 'dty748'",
            "LastUpdatedDate": "2020-04-08T00:09:49Z",
            "RouteSettings": {},
            "StageName": "$default",
            "StageVariables": {},
            "Tags": {}
        },
        {
            "AutoDeploy": true,
            "CreatedDate": "2020-04-08T00:35:06Z",
            "DefaultRouteSettings": {
                "DetailedMetricsEnabled": false
            },
            "LastUpdatedDate": "2020-04-08T00:35:48Z",
            "RouteSettings": {},
            "StageName": "dev",
            "StageVariables": {
                "function": "my-dev-function"
            },
            "Tags": {}
        },
        {
            "CreatedDate": "2020-04-08T00:36:05Z",
            "DefaultRouteSettings": {
                "DetailedMetricsEnabled": false
            },
            "DeploymentId": "x1zwyv",
            "LastUpdatedDate": "2020-04-08T00:36:13Z",
            "RouteSettings": {},
            "StageName": "prod",
            "StageVariables": {
                "function": "my-prod-function"
            },
            "Tags": {}
        }
    ]
}
```
Para obtener más información, consulte [Trabajar con etapas para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-stages.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetStages](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-stages.html)la *Referencia de AWS CLI comandos*. 

### `get-tags`
<a name="apigatewayv2_GetTags_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-tags`.

**AWS CLI**  
**Pare recuperar una lista de etiquetas para un recurso**  
En el siguiente ejemplo de `get-tags`, se genera una lista de todas las etiquetas de una API.  

```
aws apigatewayv2 get-tags \
    --resource-arn arn:aws:apigateway:us-west-2::/apis/a1b2c3d4
```
Salida:  

```
{
    "Tags": {
        "owner": "dev-team",
        "environment": "prod"
    }
}
```
Para obtener más información, consulte [Etiquetado de recursos de API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-tagging.html) la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-tags.html)la *Referencia de AWS CLI comandos*. 

### `get-vpc-link`
<a name="apigatewayv2_GetVpcLink_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-vpc-link`.

**AWS CLI**  
**Recuperación de información sobre un enlace de VPC**  
En el siguiente ejemplo de `get-vpc-link`, se muestra información acerca de un enlace de VPC.  

```
aws apigatewayv2 get-vpc-link \
    --vpc-link-id abcd123
```
Salida:  

```
{
    "CreatedDate": "2020-04-07T00:27:47Z",
    "Name": "MyVpcLink",
    "SecurityGroupIds": [
        "sg1234",
        "sg5678"
    ],
    "SubnetIds": [
        "subnet-aaaa",
        "subnet-bbbb"
    ],
    "Tags": {},
    "VpcLinkId": "abcd123",
    "VpcLinkStatus": "AVAILABLE",
    "VpcLinkStatusMessage": "VPC link is ready to route traffic",
    "VpcLinkVersion": "V2"
}
```
Para obtener más información, consulte [Uso de enlaces de VPC para HTTP APIs en la Guía para](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vpc-links.html) *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetVpcLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-vpc-link.html)la *Referencia de AWS CLI comandos*. 

### `get-vpc-links`
<a name="apigatewayv2_GetVpcLinks_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `get-vpc-links`.

**AWS CLI**  
**Recuperación de una lista de enlaces de VPC**  
En el siguiente ejemplo de `get-vpc-links`, se muestra una lista de todos los enlaces de VPC del usuario actual.  

```
aws apigatewayv2 get-vpc-links
```
Salida:  

```
{
    "Items": [
        {
            "CreatedDate": "2020-04-07T00:27:47Z",
            "Name": "MyVpcLink",
            "SecurityGroupIds": [
                "sg1234",
                "sg5678"
            ],
            "SubnetIds": [
                "subnet-aaaa",
                "subnet-bbbb"
            ],
            "Tags": {},
            "VpcLinkId": "abcd123",
            "VpcLinkStatus": "AVAILABLE",
            "VpcLinkStatusMessage": "VPC link is ready to route traffic",
            "VpcLinkVersion": "V2"
        }
        {
            "CreatedDate": "2020-04-07T00:27:47Z",
            "Name": "MyOtherVpcLink",
            "SecurityGroupIds": [
                "sg1234",
                "sg5678"
            ],
            "SubnetIds": [
                "subnet-aaaa",
                "subnet-bbbb"
            ],
            "Tags": {},
            "VpcLinkId": "abcd456",
            "VpcLinkStatus": "AVAILABLE",
            "VpcLinkStatusMessage": "VPC link is ready to route traffic",
            "VpcLinkVersion": "V2"
        }
    ]
}
```
Para obtener más información, consulte [Uso de enlaces de VPC para HTTP APIs en la Guía para](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vpc-links.html) *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [GetVpcLinks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-vpc-links.html)la *Referencia de AWS CLI comandos*. 

### `import-api`
<a name="apigatewayv2_ImportApi_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `import-api`.

**AWS CLI**  
**Importación de una API de HTTP**  
En el siguiente ejemplo de `import-api`, se crea una API de HTTP a partir de un archivo de definición de OpenAPI 3.0 denominado `api-definition.yaml`.  

```
aws apigatewayv2 import-api \
    --body file://api-definition.yaml
```
Contenido de `api-definition.yaml`:  

```
openapi: 3.0.1
info:
    title: My Lambda API
    version: v1.0
paths:
    /hello:
        x-amazon-apigateway-any-method:
            x-amazon-apigateway-integration:
                payloadFormatVersion: 2.0
                type: aws_proxy
                httpMethod: POST
                uri: arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:hello/invocations
                connectionType: INTERNET
```
Salida:  

```
{
    "ApiEndpoint": "https://a1b2c3d4.execute-api.us-west-2.amazonaws.com",
    "ApiId": "a1b2c3d4",
    "ApiKeySelectionExpression": "$request.header.x-api-key",
    "CreatedDate": "2020-04-08T17:19:38+00:00",
    "Name": "My Lambda API",
    "ProtocolType": "HTTP",
    "RouteSelectionExpression": "$request.method $request.path",
    "Tags": {},
    "Version": "v1.0"
}
```
Para obtener más información, consulte [Uso de definiciones de OpenAPI para HTTP APIs en la Guía para](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-open-api.html) *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [ImportApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/import-api.html)la *Referencia de AWS CLI comandos*. 

### `list-routing-rules`
<a name="apigatewayv2_ListRoutingRules_cli_2_topic"></a>

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

**AWS CLI**  
**Muestra de las reglas de enrutamiento**  
En el siguiente ejemplo de `list-routing-rules`, se muestran las reglas de enrutamiento de un nombre de dominio.  

```
aws apigatewayv2 list-routing-rules \
    --domain-name 'regional.example.com'
```
Salida:  

```
{
    "RoutingRules": [
        {
            "Actions": [
                {
                    "InvokeApi": {
                        "ApiId": "abcd1234",
                        "Stage": "prod",
                        "StripBasePath": false
                    }
                }
            ],
            "Conditions": [
                {
                    "MatchBasePaths": {
                        "AnyOf": [
                            "PetStoreShopper"
                        ]
                    }
                }
            ],
            "Priority": 150,
            "RoutingRuleArn": "arn:aws:apigateway:us-east-1:123456789012:/domainnames/regional.example.com/routingrules/aaa111",
            "RoutingRuleId": "aaa111"
        }
    ]
}
```
Para obtener más información, consulte [Reglas de enrutamiento para conectar las etapas de la API a un nombre de dominio personalizado para REST APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-routing-rules.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [ListRoutingRules](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/list-routing-rules.html)la *Referencia de AWS CLI comandos*. 

### `put-routing-rule`
<a name="apigatewayv2_PutRoutingRule_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `put-routing-rule`.

**AWS CLI**  
**Actualización de una regla de enrutamiento**  
En el siguiente ejemplo de `put-routing-rule`, se actualiza la prioridad de una regla de enrutamiento.  

```
aws apigatewayv2 put-routing-rule \
    --domain-name 'regional.example.com' \
    --priority 150 \
    --conditions '[ \
        { \
            "MatchBasePaths": { \
                "AnyOf": [ \
                    "PetStoreShopper" \
                ] \
            } \
        } \
    ]' \
    --actions '[ \
        { \
            "InvokeApi": { \
                "ApiId": "abcd1234", \
                "Stage": "prod" \
            } \
        } \
    ]'
```
Salida:  

```
{
    "Actions": [
        {
            "InvokeApi": {
                "ApiId": "abcd1234",
                "Stage": "prod",
                "StripBasePath": false
            }
        }
    ],
    "Conditions": [
        {
            "MatchBasePaths": {
                "AnyOf": [
                    "PetStoreShopper"
                ]
            }
        }
    ],
    "Priority": 150,
    "RoutingRuleArn": "arn:aws:apigateway:us-east-2:123456789012:/domainnames/regional.example.com/routingrules/aaa111",
    "RoutingRuleId": "aaa111"
}
```
Para obtener más información, consulte [Reglas de enrutamiento para conectar las etapas de la API a un nombre de dominio personalizado para REST APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-routing-rules.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [PutRoutingRule](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/put-routing-rule.html)la *Referencia de AWS CLI comandos*. 

### `reimport-api`
<a name="apigatewayv2_ReimportApi_cli_2_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `reimport-api`.

**AWS CLI**  
**Reimportación de una API de HTTP**  
En el siguiente ejemplo de `reimport-api`, se actualiza una API de HTTP existente para utilizar la definición de OpenAPI 3.0 especificada en `api-definition.yaml`.  

```
aws apigatewayv2 reimport-api \
    --body file://api-definition.yaml \
    --api-id a1b2c3d4
```
Contenido de `api-definition.yaml`:  

```
openapi: 3.0.1
info:
    title: My Lambda API
    version: v1.0
paths:
    /hello:
        x-amazon-apigateway-any-method:
            x-amazon-apigateway-integration:
                payloadFormatVersion: 2.0
                type: aws_proxy
                httpMethod: POST
                uri: arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:12356789012:function:hello/invocations
                connectionType: INTERNET
```
Salida:  

```
{
    "ApiEndpoint": "https://a1b2c3d4.execute-api.us-west-2.amazonaws.com",
    "ApiId": "a1b2c3d4",
    "ApiKeySelectionExpression": "$request.header.x-api-key",
    "CreatedDate": "2020-04-08T17:19:38+00:00",
    "Name": "My Lambda API",
    "ProtocolType": "HTTP",
    "RouteSelectionExpression": "$request.method $request.path",
    "Tags": {},
    "Version": "v1.0"
}
```
Para obtener más información, consulte [Uso de definiciones de OpenAPI para HTTP APIs en la Guía para](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-open-api.html) *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [ReimportApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/reimport-api.html)la *Referencia de AWS CLI comandos*. 

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

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 una etiqueta con el nombre de clave `Department` y un valor de `Accounting` a la API especificada.  

```
aws apigatewayv2 tag-resource \
    --resource-arn arn:aws:apigateway:us-west-2::/apis/a1b2c3d4 \
    --tags Department=Accounting
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Etiquetado de recursos de API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-tagging.html) la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/tag-resource.html)la *Referencia de AWS CLI comandos*. 

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

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

**AWS CLI**  
**Para eliminar etiquetas de un recurso**  
En el siguiente ejemplo de `untag-resource`, se eliminan las etiquetas con los nombres de clave `Project` y `Owner` de la API especificada.  

```
aws apigatewayv2 untag-resource \
    --resource-arn arn:aws:apigateway:us-west-2::/apis/a1b2c3d4 \
    --tag-keys Project Owner
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [Etiquetado de recursos de API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-tagging.html) la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [UntagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/untag-resource.html)la *Referencia de AWS CLI comandos*. 

### `update-api-mapping`
<a name="apigatewayv2_UpdateApiMapping_cli_2_topic"></a>

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

**AWS CLI**  
**Actualización de una asignación de API**  
En el siguiente ejemplo de `update-api-mapping`, se cambia una asignación de API de un nombre de dominio personalizado. Como resultado, la URL base que utiliza el nombre de dominio personalizado para la API especificada y la etapa se convierte en `https://api.example.com/dev`.  

```
aws apigatewayv2 update-api-mapping \
    --api-id a1b2c3d4 \
    --stage dev \
    --domain-name api.example.com \
    --api-mapping-id 0qzs2sy7bh \
    --api-mapping-key dev
```
Salida:  

```
{
    "ApiId": "a1b2c3d4",
    "ApiMappingId": "0qzs2sy7bh",
    "ApiMappingKey": "dev"
    "Stage": "dev"
}
```
Para obtener más información, consulte [Configuración de un nombre de dominio personalizado regional en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [UpdateApiMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-api-mapping.html)la *Referencia de AWS CLI comandos*. 

### `update-api`
<a name="apigatewayv2_UpdateApi_cli_2_topic"></a>

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

**AWS CLI**  
**Habilitación de CORS para una API de HTTP**  
En el siguiente ejemplo de `update-api`, se actualiza la configuración CORS de la API especificada para admitir solicitudes de `https://www.example.com`.  

```
aws apigatewayv2 update-api \
    --api-id a1b2c3d4 \
    --cors-configuration AllowOrigins=https://www.example.com
```
Salida:  

```
{
    "ApiEndpoint": "https://a1b2c3d4.execute-api.us-west-2.amazonaws.com",
    "ApiId": "a1b2c3d4",
    "ApiKeySelectionExpression": "$request.header.x-api-key",
    "CorsConfiguration": {
        "AllowCredentials": false,
        "AllowHeaders": [
            "header1",
            "header2"
        ],
        "AllowMethods": [
            "GET",
            "OPTIONS"
        ],
        "AllowOrigins": [
            "https://www.example.com"
        ]
    },
    "CreatedDate": "2020-04-08T18:39:37+00:00",
    "Name": "my-http-api",
    "ProtocolType": "HTTP",
    "RouteSelectionExpression": "$request.method $request.path",
    "Tags": {},
    "Version": "v1.0"
}
```
Para obtener más información, consulte [Configuración de CORS de las API de HTTP en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-cors.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [UpdateApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-api.html)la *Referencia de AWS CLI comandos*. 

### `update-authorizer`
<a name="apigatewayv2_UpdateAuthorizer_cli_2_topic"></a>

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

**AWS CLI**  
**Actualización de un autorizador**  
En el siguiente ejemplo de `update-authorizer`, se cambia una fuente de identidad del autorizador de JWT por un encabezado denominado `Authorization`.  

```
aws apigatewayv2 update-authorizer \
    --api-id a1b2c3d4 \
    --authorizer-id a1b2c3 \
    --identity-source '$request.header.Authorization'
```
Salida:  

```
{
    "AuthorizerId": "a1b2c3",
    "AuthorizerType": "JWT",
    "IdentitySource": [
        "$request.header.Authorization"
    ],
    "JwtConfiguration": {
        "Audience": [
            "123456abc"
        ],
        "Issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_abc123"
    },
    "Name": "my-jwt-authorizer"
}
```
Para obtener más información, consulte [Control del acceso a HTTP APIs con autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) en la Guía para *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte la Referencia [UpdateAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-authorizer.html)de *AWS CLI comandos*. 

### `update-deployment`
<a name="apigatewayv2_UpdateDeployment_cli_2_topic"></a>

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

**AWS CLI**  
**Cambio de la descripción de una implementación**  
En el siguiente ejemplo de `update-deployment`, se actualiza la descripción de una implementación.  

```
aws apigatewayv2 update-deployment \
    --api-id a1b2c3d4 \
    --deployment-id abcdef \
    --description 'Manual deployment to fix integration test failures.'
```
Salida:  

```
{
    "AutoDeployed": false,
    "CreatedDate": "2020-02-05T16:21:48+00:00",
    "DeploymentId": "abcdef",
    "DeploymentStatus": "DEPLOYED",
    "Description": "Manual deployment to fix integration test failures."
}
```
Para obtener más información, consulte [Desarrollo de las API de HTTP en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [UpdateDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-deployment.html)la *Referencia de AWS CLI comandos*. 

### `update-domain-name`
<a name="apigatewayv2_UpdateDomainName_cli_2_topic"></a>

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

**AWS CLI**  
**Actualización de un nombre de dominio personalizado**  
En el siguiente ejemplo de `update-domain-name`, se especifica un nuevo certificado de ACM para el nombre de dominio personalizado `api.example.com`.  

```
aws apigatewayv2 update-domain-name \
    --domain-name api.example.com \
    --domain-name-configurations CertificateArn=arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678
```
Salida:  

```
{
    "ApiMappingSelectionExpression": "$request.basepath",
    "DomainName": "regional.example.com",
    "DomainNameConfigurations": [
        {
            "ApiGatewayDomainName": "d-id.execute-api.us-west-2.amazonaws.com",
            "CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678",
            "EndpointType": "REGIONAL",
            "HostedZoneId": "123456789111",
            "SecurityPolicy": "TLS_1_2",
            "DomainNameStatus": "AVAILABLE"
        }
    ]
}
```
Para obtener más información, consulte [Configuración de un nombre de dominio personalizado regional en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [UpdateDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-domain-name.html)la *Referencia de AWS CLI comandos*. 

### `update-integration`
<a name="apigatewayv2_UpdateIntegration_cli_2_topic"></a>

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

**AWS CLI**  
**Actualización de una integración de Lambda**  
El siguiente `update-integration` ejemplo actualiza una integración AWS Lambda existente para usar la función Lambda especificada.  

```
aws apigatewayv2 update-integration \
    --api-id a1b2c3d4 \
    --integration-id a1b2c3 \
    --integration-uri arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:my-new-function/invocations
```
Salida:  

```
{
    "ConnectionType": "INTERNET",
    "IntegrationId": "a1b2c3",
    "IntegrationMethod": "POST",
    "IntegrationType": "AWS_PROXY",
    "IntegrationUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:my-new-function/invocations",
    "PayloadFormatVersion": "2.0",
    "TimeoutInMillis": 5000
}
```
Para obtener más información, consulte [Configuración de integraciones para HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations.html) y [Configuración de integraciones de WebSocket API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-integrations.html) en la Guía para *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte la Referencia [UpdateIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-integration.html)de *AWS CLI comandos*. 

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

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

**AWS CLI**  
**Ejemplo 1: cómo actualizar la integración de una ruta**  
En el siguiente ejemplo de `update-route`, se actualiza la integración de una ruta especificada.  

```
aws apigatewayv2 update-route \
    --api-id a1b2c3d4 \
    --route-id a1b2c3 \
    --target integrations/a1b2c6
```
Salida:  

```
{
    "ApiKeyRequired": false,
    "AuthorizationType": "NONE",
    "RouteId": "a1b2c3",
    "RouteKey": "ANY /pets",
    "Target": "integrations/a1b2c6"
}
```
**Ejemplo 2: cómo añadir un autorizador a una ruta**  
En el siguiente ejemplo de `update-route`, se actualiza la ruta especificada para que utilice un autorizador de JWT.  

```
aws apigatewayv2 update-route \
    --api-id a1b2c3d4  \
    --route-id a1b2c3  \
    --authorization-type JWT \
    --authorizer-id a1b2c5 \
    --authorization-scopes user.id user.email
```
Salida:  

```
{
    "ApiKeyRequired": false,
    "AuthorizationScopes": [
        "user.id",
        "user.email"
    ],
    "AuthorizationType": "JWT",
    "AuthorizerId": "a1b2c5",
    "OperationName": "GET HTTP",
    "RequestParameters": {},
    "RouteId": "a1b2c3",
    "RouteKey": "GET /pets",
    "Target": "integrations/a1b2c6"
}
```
Para obtener más información, consulte [Control del acceso a HTTP APIs con autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) en la Guía para *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte la Referencia [UpdateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-route.html)de *AWS CLI comandos*. 

### `update-stage`
<a name="apigatewayv2_UpdateStage_cli_2_topic"></a>

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

**AWS CLI**  
**Configuración de una limitación personalizada**  
En el siguiente ejemplo de `update-stage`, se configura la limitación personalizada de la etapa y la ruta especificadas de una API.  

```
aws apigatewayv2 update-stage \
    --api-id a1b2c3d4 \
    --stage-name dev \
    --route-settings '{"GET /pets":{"ThrottlingBurstLimit":100,"ThrottlingRateLimit":2000}}'
```
Salida:  

```
{
    "CreatedDate": "2020-04-05T16:21:16+00:00",
    "DefaultRouteSettings": {
        "DetailedMetricsEnabled": false
    },
    "DeploymentId": "shktxb",
    "LastUpdatedDate": "2020-04-08T22:23:17+00:00",
    "RouteSettings": {
        "GET /pets": {
            "ThrottlingBurstLimit": 100,
            "ThrottlingRateLimit": 2000.0
        }
    },
    "StageName": "dev",
    "StageVariables": {},
    "Tags": {}
}
```
Para obtener más información, consulte [Protección de sus API de HTTP en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-protect.html) en la *Guía para desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [UpdateStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-stage.html)la *Referencia de AWS CLI comandos*. 

### `update-vpc-link`
<a name="apigatewayv2_UpdateVpcLink_cli_2_topic"></a>

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

**AWS CLI**  
**Actualización de un enlace de VPC**  
En el siguiente ejemplo de `update-vpc-link`, se actualiza el nombre de un enlace de VPC. Después de crear un enlace de VPC, no puede cambiar sus subredes ni grupos de seguridad.  

```
aws apigatewayv2 update-vpc-link \
    --vpc-link-id abcd123 \
    --name MyUpdatedVpcLink
```
Salida:  

```
{
    "CreatedDate": "2020-04-07T00:27:47Z",
    "Name": "MyUpdatedVpcLink",
    "SecurityGroupIds": [
        "sg1234",
        "sg5678"
    ],
    "SubnetIds": [
        "subnet-aaaa",
        "subnet-bbbb"
    ],
    "Tags": {},
    "VpcLinkId": "abcd123",
    "VpcLinkStatus": "AVAILABLE",
    "VpcLinkStatusMessage": "VPC link is ready to route traffic",
    "VpcLinkVersion": "V2"
}
```
Para obtener más información, consulte [Uso de enlaces de VPC para HTTP APIs en la Guía para](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vpc-links.html) *desarrolladores de Amazon API Gateway*.  
+  Para obtener más información sobre la API, consulte [UpdateVpcLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-vpc-link.html)la *Referencia de AWS CLI comandos*.