# Ejemplos de API Gateway que utilizan la AWS CLI
En los siguientes ejemplos de código, se muestra cómo realizar acciones e implementar escenarios comunes mediante AWS Command Line Interface con una puerta de enlace de API.
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
### `create-api-key`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-api-key`.
**AWS CLI**
**Creación de una clave de API que esté habilitada para una API y una etapa existentes**
Comando:
```
aws apigateway create-api-key --name 'Dev API Key' --description 'Used for development' --enabled --stage-keys restApiId='a1b2c3d4e5',stageName='dev'
```
+ Para obtener información sobre la API, consulte [CreateApiKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-api-key.html) en la *Referencia de comandos de la AWS CLI*.
### `create-authorizer`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-authorizer`.
**AWS CLI**
**Ejemplo 1: cómo crear un autorizador personalizado de API Gateway basado en tokens para la API**
En el siguiente ejemplo de `create-authorizer`, se crea un autorizador basado en tokens.
```
aws apigateway create-authorizer \
--rest-api-id 1234123412 \
--name 'First_Token_Custom_Authorizer' \
--type TOKEN \
--authorizer-uri 'arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:customAuthFunction/invocations' \
--identity-source 'method.request.header.Authorization' \
--authorizer-result-ttl-in-seconds 300
```
Salida:
```
{
"authType": "custom",
"name": "First_Token_Custom_Authorizer",
"authorizerUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:customAuthFunction/invocations",
"authorizerResultTtlInSeconds": 300,
"identitySource": "method.request.header.Authorization",
"type": "TOKEN",
"id": "z40xj0"
}
```
**Ejemplo 2: cómo crear un autorizador personalizado de API Gateway basado en grupos de usuarios de Cognito para la API**
En el siguiente ejemplo de `create-authorizer`, se crea un autorizador personalizado de API Gateway basado en grupos de usuarios de Cognito.
```
aws apigateway create-authorizer \
--rest-api-id 1234123412 \
--name 'First_Cognito_Custom_Authorizer' \
--type COGNITO_USER_POOLS \
--provider-arns 'arn:aws:cognito-idp:us-east-1:123412341234:userpool/us-east-1_aWcZeQbuD' \
--identity-source 'method.request.header.Authorization'
```
Salida:
```
{
"authType": "cognito_user_pools",
"identitySource": "method.request.header.Authorization",
"name": "First_Cognito_Custom_Authorizer",
"providerARNs": [
"arn:aws:cognito-idp:us-east-1:342398297714:userpool/us-east-1_qWbZzQhzE"
],
"type": "COGNITO_USER_POOLS",
"id": "5yid1t"
}
```
**Ejemplo 3: cómo crear un autorizador personalizado de API Gateway basado solicitudes para la API**
En el siguiente ejemplo de `create-authorizer`, se crea un autorizador basado solicitudes.
```
aws apigateway create-authorizer \
--rest-api-id 1234123412 \
--name 'First_Request_Custom_Authorizer' \
--type REQUEST \
--authorizer-uri 'arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:customAuthFunction/invocations' \
--identity-source 'method.request.header.Authorization,context.accountId' \
--authorizer-result-ttl-in-seconds 300
```
Salida:
```
{
"id": "z40xj0",
"name": "First_Request_Custom_Authorizer",
"type": "REQUEST",
"authType": "custom",
"authorizerUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:customAuthFunction/invocations",
"identitySource": "method.request.header.Authorization,context.accountId",
"authorizerResultTtlInSeconds": 300
}
```
+ Para obtener información sobre la API, consulte [CreateAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-authorizer.html) en la *Referencia de comandos de la AWS CLI*.
### `create-base-path-mapping`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-base-path-mapping`.
**AWS CLI**
**Creación de la asignación de ruta base para un nombre de dominio personalizado**
Comando:
```
aws apigateway create-base-path-mapping --domain-name subdomain.domain.tld --rest-api-id 1234123412 --stage prod --base-path v1
```
+ Para obtener información sobre la API, consulte [CreateBasePathMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-base-path-mapping.html) en la *Referencia de comandos de la AWS CLI*.
### `create-deployment`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-deployment`.
**AWS CLI**
**Para implementar los recursos configurados para una API en una nueva etapa**
Comando:
```
aws apigateway create-deployment --rest-api-id 1234123412 --stage-name dev --stage-description 'Development Stage' --description 'First deployment to the dev stage'
```
**Para implementar los recursos configurados para una API en una etapa existente**
Comando:
```
aws apigateway create-deployment --rest-api-id 1234123412 --stage-name dev --description 'Second deployment to the dev stage'
```
**Para implementar los recursos configurados para una API en una etapa existente con variables de etapa**
aws apigateway create-deployment --rest-api-id 1234123412 --stage-name dev --description 'Third deployment to the dev stage' --variables key='value',otherKey='otherValue'
+ Para obtener información sobre la API, consulte [CreateDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-deployment.html) en la *Referencia de comandos de la AWS CLI*.
### `create-domain-name-access-association`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-domain-name-access-association`.
**AWS CLI**
**Creación de una asociación de acceso a nombres de dominio**
En el siguiente ejemplo de `create-domain-name-access-association`, se crea una asociación de acceso a un nombre de dominio entre un nombre de dominio personalizado privado y un punto de conexión de VPC.
```
aws apigateway create-domain-name-access-association \
--domain-name-arn arn:aws:apigateway:us-west-2:111122223333:/domainnames/my.private.domain.tld+abcd1234 \
--access-association-source vpce-abcd1234efg \
--access-association-source-type VPCE
```
Salida:
```
{
"domainNameAccessAssociationArn": "arn:aws:apigateway:us-west-2:012345678910:/domainnameaccessassociations/domainname/my.private.domain.tld/vpcesource/vpce-abcd1234efg
"accessAssociationSource": "vpce-abcd1234efg",
"accessAssociationSourceType": "VPCE",
"domainNameArn" : "arn:aws:apigateway:us-west-2:111122223333:/domainnames/private.example.com+abcd1234"
}
```
Para obtener más información, consulte [Nombres de dominio personalizados para las API privadas en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
+ Para obtener información sobre la API, consulte [CreateDomainNameAccessAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-domain-name-access-association.html) en *Referencia de comandos de AWS CLI*.
### `create-domain-name`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-domain-name`.
**AWS CLI**
**Ejemplo 1: creación de un nombre de dominio público personalizado**
En el siguiente ejemplo de `create-domain-name`, se crea un nombre de dominio personalizado público.
```
aws apigateway create-domain-name \
--domain-name 'my.domain.tld' \
--certificate-name 'my.domain.tld cert'\
--certificate-arn 'arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3'
```
Salida:
```
{
"domainName": "my.domain.tld",
"certificateName": "my.domain.tld cert",
"certificateArn": "arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3",
"certificateUploadDate": "2024-10-08T11:29:49-07:00",
"distributionDomainName": "abcd1234.cloudfront.net",
"distributionHostedZoneId": "Z2FDTNDATAQYW2",
"endpointConfiguration": {
"types": [
"EDGE"
]
},
"domainNameStatus": "AVAILABLE",
"securityPolicy": "TLS_1_2"
}
```
Para obtener más información, consulte [Nombre de dominio personalizado para las API de REST públicas en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
**Ejemplo 2: creación de un nombre de dominio privado personalizado**
En el siguiente ejemplo de `create-domain-name`, se crea un nombre de dominio personalizado privado.
```
aws apigateway create-domain-name \
--domain-name 'my.private.domain.tld' \
--certificate-name 'my.domain.tld cert' \
--certificate-arn 'arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3' \
--endpoint-configuration '{"types": ["PRIVATE"]}' \
--security-policy 'TLS_1_2' \
--policy file://policy.json
```
Contenido de `policy.json`:
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": [
"execute-api:/*"
]
},
{
"Effect": "Deny",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": [
"execute-api:/*"
],
"Condition" : {
"StringNotEquals": {
"aws:SourceVpce": "vpce-abcd1234efg"
}
}
}
]
}
```
Salida:
```
{
"domainName": "my.private.domain.tld",
"domainNameId": "abcd1234",
"domainNameArn": "arn:aws:apigateway:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234",
"certificateArn": "arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3",
"certificateUploadDate": "2024-09-10T10:31:20-07:00",
"endpointConfiguration": {
"types": [
"PRIVATE"
]
},
"domainNameStatus": "AVAILABLE",
"securityPolicy": "TLS_1_2",
"policy": "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":\"*\",\"Action\":\"execute-api:Invoke\",\"Resource\":\"arn:aws:execute-api:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234\"},{\"Effect\":\"Deny\",\"Principal\":\"*\",\"Action\":\"execute-api:Invoke\",\"Resource\":\"arn:aws:execute-api:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234\",\"Condition\":{\"StringNotEquals\":{\"aws:SourceVpc\":\"vpc-1a2b3c4d\"}}}]}"
}
```
Para obtener más información, consulte [Nombre de dominio personalizado para las API de REST públicas en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
+ Para obtener información sobre la API, consulte [CreateDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-domain-name.html) en la *Referencia de comandos de la AWS CLI*.
### `create-model`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-model`.
**AWS CLI**
**Creación de un modelo para una API**
Comando:
```
aws apigateway create-model --rest-api-id 1234123412 --name 'firstModel' --description 'The First Model' --content-type 'application/json' --schema '{ "$schema": "http://json-schema.org/draft-04/schema#", "title": "firstModel", "type": "object", "properties": { "firstProperty" : { "type": "object", "properties": { "key": { "type": "string" } } } } }'
```
Salida:
```
{
"contentType": "application/json",
"description": "The First Model",
"name": "firstModel",
"id": "2rzg0l",
"schema": "{ \"$schema\": \"http://json-schema.org/draft-04/schema#\", \"title\": \"firstModel\", \"type\": \"object\", \"properties\": { \"firstProperty\" : { \"type\": \"object\", \"properties\": { \"key\": { \"type\": \"string\" } } } } }"
}
```
+ Para obtener información sobre la API, consulte [CreateModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-model.html) en la *Referencia de comandos de la AWS CLI*.
### `create-resource`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-resource`.
**AWS CLI**
**Creación de un recurso en una API**
Comando:
```
aws apigateway create-resource --rest-api-id 1234123412 --parent-id a1b2c3 --path-part 'new-resource'
```
+ Para obtener información sobre la API, consulte [CreateResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-resource.html) en la *Referencia de comandos de la AWS CLI*.
### `create-rest-api`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-rest-api`.
**AWS CLI**
**Creación de una API**
Comando:
```
aws apigateway create-rest-api --name 'My First API' --description 'This is my first API'
```
**Para crear una API duplicada a partir de una API existente**
Comando:
```
aws apigateway create-rest-api --name 'Copy of My First API' --description 'This is a copy of my first API' --clone-from 1234123412
```
+ Para obtener información sobre la API, consulte [CreateRestApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-rest-api.html) en la *Referencia de comandos de la AWS CLI*.
### `create-stage`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-stage`.
**AWS CLI**
**Creación de una etapa en una API que contenga una implementación existente**
Comando:
```
aws apigateway create-stage --rest-api-id 1234123412 --stage-name 'dev' --description 'Development stage' --deployment-id a1b2c3
```
**Creación de una etapa en una API que contenga una implementación existente y variables de etapa personalizadas**
Comando:
```
aws apigateway create-stage --rest-api-id 1234123412 --stage-name 'dev' --description 'Development stage' --deployment-id a1b2c3 --variables key='value',otherKey='otherValue'
```
+ Para obtener información sobre la API, consulte [CreateStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-stage.html) en la *Referencia de comandos de la AWS CLI*.
### `create-usage-plan-key`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-usage-plan-key`.
**AWS CLI**
**Asociación de una clave de API existente a un plan de uso**
Comando:
```
aws apigateway create-usage-plan-key --usage-plan-id a1b2c3 --key-type "API_KEY" --key-id 4vq3yryqm5
```
+ Para obtener información sobre la API, consulte [CreateUsagePlanKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-usage-plan-key.html) en la *Referencia de comandos de la AWS CLI*.
### `create-usage-plan`
En el siguiente ejemplo de código, se muestra cómo utilizar `create-usage-plan`.
**AWS CLI**
**Creación de un plan de uso con límites de cuota y limitación que se restablezca a principios de mes**
Comando:
```
aws apigateway create-usage-plan --name "New Usage Plan" --description "A new usage plan" --throttle burstLimit=10,rateLimit=5 --quota limit=500,offset=0,period=MONTH
```
+ Para obtener información sobre la API, consulte [CreateUsagePlan](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-usage-plan.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-api-key`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-api-key`.
**AWS CLI**
**Eliminación de una clave de API**
Comando:
```
aws apigateway delete-api-key --api-key 8bklk8bl1k3sB38D9B3l0enyWT8c09B30lkq0blk
```
+ Para obtener información sobre la API, consulte [DeleteApiKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-api-key.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-authorizer`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-authorizer`.
**AWS CLI**
**Eliminación de un autorizador personalizado de una API**
Comando:
```
aws apigateway delete-authorizer --rest-api-id 1234123412 --authorizer-id 7gkfbo
```
+ Para obtener detalles sobre la API, consulte [DeleteAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-authorizer.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-base-path-mapping`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-base-path-mapping`.
**AWS CLI**
**Eliminación de la asignación de ruta base de un nombre de dominio personalizado**
Comando:
```
aws apigateway delete-base-path-mapping --domain-name 'api.domain.tld' --base-path 'dev'
```
+ Para obtener información sobre la API, consulte [DeleteBasePathMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-base-path-mapping.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-client-certificate`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-client-certificate`.
**AWS CLI**
**Eliminación de un certificado de cliente**
Comando:
```
aws apigateway delete-client-certificate --client-certificate-id a1b2c3
```
+ Para obtener información sobre la API, consulte [DeleteClientCertificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-client-certificate.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-deployment`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-deployment`.
**AWS CLI**
**Para eliminar una implementación en una API**
Comando:
```
aws apigateway delete-deployment --rest-api-id 1234123412 --deployment-id a1b2c3
```
+ Para obtener información sobre la API, consulte [DeleteDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-deployment.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-domain-name-access-association`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-domain-name-access-association`.
**AWS CLI**
**Eliminación de una asociación de acceso a nombres de dominio**
En el siguiente ejemplo de `delete-domain-name-access-association`, se elimina una asociación de acceso a un nombre de dominio entre un nombre de dominio personalizado privado y un punto de conexión de VPC.
```
aws apigateway delete-domain-name-access-association \
--domain-name-access-association-arn arn:aws:apigateway:us-west-2:012345678910:/domainnameaccessassociations/domainname/my.private.domain.tld/vpcesource/vpce-abcd1234efg
```
Este comando no genera ninguna salida.
Para obtener más información, consulte [Nombres de dominio personalizados para las API privadas en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
+ Para obtener información sobre la API, consulte [DeleteDomainNameAccessAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-domain-name-access-association.html) en *Referencia de comandos de la AWS CLI*.
### `delete-domain-name`
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**
Comando:
```
aws apigateway delete-domain-name --domain-name 'api.domain.tld'
```
+ Para obtener información sobre la API, consulte [DeleteDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-domain-name.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-integration-response`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-integration-response`.
**AWS CLI**
**Eliminación de una respuesta de integración de un recurso, método y código de estado determinados en una API**
Comando:
```
aws apigateway delete-integration-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 200
```
+ Para obtener información sobre la API, consulte [DeleteIntegrationResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-integration-response.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-integration`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-integration`.
**AWS CLI**
**Eliminación de una integración de un recurso y método determinados en una API**
Comando:
```
aws apigateway delete-integration --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET
```
+ Para obtener información sobre la API, consulte [DeleteIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-integration.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-method-response`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-method-response`.
**AWS CLI**
**Eliminación de una respuesta de método de un recurso, método y código de estado determinados en una API**
Comando:
```
aws apigateway delete-method-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 200
```
+ Para obtener información sobre la API, consulte [DeleteMethodResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-method-response.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-method`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-method`.
**AWS CLI**
**Eliminación de un método de un recurso determinado en una API**
Comando:
```
aws apigateway delete-method --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET
```
+ Para obtener información sobre la API, consulte [DeleteMethod](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-method.html) en la *Referencia de comandos de AWS CLI*.
### `delete-model`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-model`.
**AWS CLI**
**Eliminación de un modelo en una API determinada**
Comando:
```
aws apigateway delete-model --rest-api-id 1234123412 --model-name 'customModel'
```
+ Para obtener información sobre la API, consulte [DeleteModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-model.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-resource`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-resource`.
**AWS CLI**
**Eliminación de un recurso en una API**
Comando:
```
aws apigateway delete-resource --rest-api-id 1234123412 --resource-id a1b2c3
```
+ Para obtener información sobre la API, consulte [DeleteResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-resource.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-rest-api`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-rest-api`.
**AWS CLI**
**Eliminación de una API**
Comando:
```
aws apigateway delete-rest-api --rest-api-id 1234123412
```
+ Para obtener información sobre la API, consulte [DeleteRestApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-rest-api.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-stage`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-stage`.
**AWS CLI**
**Para eliminar una etapa en una API**
Comando:
```
aws apigateway delete-stage --rest-api-id 1234123412 --stage-name 'dev'
```
+ Para obtener información sobre la API, consulte [DeleteStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-stage.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-usage-plan-key`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-usage-plan-key`.
**AWS CLI**
**Eliminación de una clave de API de un plan de uso**
Comando:
```
aws apigateway delete-usage-plan-key --usage-plan-id a1b2c3 --key-id 1NbjQzMReAkeEQPNAW8r3dXsU2rDD7fc7f2Sipnu
```
+ Para obtener información sobre la API, consulte [DeleteUsagePlanKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-usage-plan-key.html) en la *Referencia de comandos de la AWS CLI*.
### `delete-usage-plan`
En el siguiente ejemplo de código, se muestra cómo utilizar `delete-usage-plan`.
**AWS CLI**
**Eliminación de un plan de uso**
Comando:
```
aws apigateway delete-usage-plan --usage-plan-id a1b2c3
```
+ Para obtener información sobre la API, consulte [DeleteUsagePlan](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-usage-plan.html) en la *Referencia de comandos de la AWS CLI*.
### `flush-stage-authorizers-cache`
En el siguiente ejemplo de código, se muestra cómo utilizar `flush-stage-authorizers-cache`.
**AWS CLI**
**Vaciado de todas las entradas de la caché del autorizador en una etapa**
Comando:
```
aws apigateway flush-stage-authorizers-cache --rest-api-id 1234123412 --stage-name dev
```
+ Para obtener información sobre la API, consulte [FlushStageAuthorizersCache](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/flush-stage-authorizers-cache.html) en la *Referencia de comandos de la AWS CLI*.
### `flush-stage-cache`
En el siguiente ejemplo de código, se muestra cómo utilizar `flush-stage-cache`.
**AWS CLI**
**Vaciado de la caché de una etapa de la API**
En el siguiente ejemplo de `flush-stage-cache`, se vacía la caché de una etapa.
```
aws apigateway flush-stage-cache \
--rest-api-id 1234123412 \
--stage-name dev
```
Este comando no genera ninguna salida.
Para obtener más información, consulte [Vaciar la caché de etapas de API en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-caching.html#flush-api-caching) en la *Guía para desarrolladores de Amazon API Gateway*.
+ Para obtener información sobre la API, consulte [FlushStageCache](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/flush-stage-cache.html) en la *Referencia de comandos de la AWS CLI*.
### `generate-client-certificate`
En el siguiente ejemplo de código, se muestra cómo utilizar `generate-client-certificate`.
**AWS CLI**
**Creación de un certificado SSL del cliente**
Comando:
```
aws apigateway generate-client-certificate --description 'My First Client Certificate'
```
+ Para obtener información sobre la API, consulte [GenerateClientCertificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/generate-client-certificate.html) en la *Referencia de comandos de la AWS CLI*.
### `get-account`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-account`.
**AWS CLI**
**Para obtener la configuración de cuenta de API Gateway**
Comando:
```
aws apigateway get-account
```
Salida:
```
{
"cloudwatchRoleArn": "arn:aws:iam::123412341234:role/APIGatewayToCloudWatchLogsRole",
"throttleSettings": {
"rateLimit": 500.0,
"burstLimit": 1000
}
}
```
+ Para obtener información sobre la API, consulte [GetAccount](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-account.html) en la *Referencia de comandos de la AWS CLI*.
### `get-api-key`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-api-key`.
**AWS CLI**
**Para obtener información acerca de una clave de API específica**
Comando:
```
aws apigateway get-api-key --api-key 8bklk8bl1k3sB38D9B3l0enyWT8c09B30lkq0blk
```
Salida:
```
{
"description": "My first key",
"enabled": true,
"stageKeys": [
"a1b2c3d4e5/dev",
"e5d4c3b2a1/dev"
],
"lastUpdatedDate": 1456184515,
"createdDate": 1456184452,
"id": "8bklk8bl1k3sB38D9B3l0enyWT8c09B30lkq0blk",
"name": "My key"
}
```
+ Para obtener información sobre la API, consulte [GetApiKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-api-key.html) en la *Referencia de comandos de la AWS CLI*.
### `get-api-keys`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-api-keys`.
**AWS CLI**
**Para obtener la lista de claves de API**
Comando:
```
aws apigateway get-api-keys
```
Salida:
```
{
"items": [
{
"description": "My first key",
"enabled": true,
"stageKeys": [
"a1b2c3d4e5/dev",
"e5d4c3b2a1/dev"
],
"lastUpdatedDate": 1456184515,
"createdDate": 1456184452,
"id": "8bklk8bl1k3sB38D9B3l0enyWT8c09B30lkq0blk",
"name": "My key"
}
]
}
```
+ Para obtener información sobre la API, consulte [GetApiKeys](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-api-keys.html) en la *Referencia de comandos de la AWS CLI*.
### `get-authorizer`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-authorizer`.
**AWS CLI**
**Para obtener la configuración del autorizador por API de API Gateway**
Comando:
```
aws apigateway get-authorizer --rest-api-id 1234123412 --authorizer-id gfi4n3
```
Salida:
```
{
"authorizerResultTtlInSeconds": 300,
"name": "MyAuthorizer",
"type": "TOKEN",
"identitySource": "method.request.header.Authorization",
"authorizerUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:authorizer_function/invocations",
"id": "gfi4n3"
}
```
+ Para obtener información sobre la API, consulte [GetAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-authorizer.html) en la *Referencia de comandos de la AWS CLI*.
### `get-authorizers`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-authorizers`.
**AWS CLI**
**Para obtener la lista de autorizadores de una API de REST**
Comando:
```
aws apigateway get-authorizers --rest-api-id 1234123412
```
Salida:
```
{
"items": [
{
"name": "MyAuthorizer",
"authorizerUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:My_Authorizer_Function/invocations",
"authorizerResultTtlInSeconds": 300,
"identitySource": "method.request.header.Authorization",
"type": "TOKEN",
"id": "gfi4n3"
}
]
}
```
+ Para obtener información sobre la API, consulte [GetAuthorizers](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-authorizers.html) en la *Referencia de comandos de la AWS CLI*.
### `get-base-path-mapping`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-base-path-mapping`.
**AWS CLI**
**Obtención de la asignación de ruta base para un nombre de dominio personalizado**
Comando:
```
aws apigateway get-base-path-mapping --domain-name subdomain.domain.tld --base-path v1
```
Salida:
```
{
"basePath": "v1",
"restApiId": "1234w4321e",
"stage": "api"
}
```
+ Para obtener información sobre la API, consulte [GetBasePathMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-base-path-mapping.html) en la *Referencia de comandos de la AWS CLI*.
### `get-base-path-mappings`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-base-path-mappings`.
**AWS CLI**
**Para obtener las asignaciones de ruta base de un nombre de dominio personalizado**
Comando:
```
aws apigateway get-base-path-mappings --domain-name subdomain.domain.tld
```
Salida:
```
{
"items": [
{
"basePath": "(none)",
"restApiId": "1234w4321e",
"stage": "dev"
},
{
"basePath": "v1",
"restApiId": "1234w4321e",
"stage": "api"
}
]
}
```
+ Para obtener información sobre la API, consulte [GetBasePathMappings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-base-path-mappings.html) en la *Referencia de comandos de la AWS CLI*.
### `get-client-certificate`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-client-certificate`.
**AWS CLI**
**Para obtener un certificado de cliente**
Comando:
```
aws apigateway get-client-certificate --client-certificate-id a1b2c3
```
+ Para obtener información sobre la API, consulte [GetClientCertificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-client-certificate.html) en la *Referencia de comandos de la AWS CLI*.
### `get-client-certificates`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-client-certificates`.
**AWS CLI**
**Para obtener una lista de certificados de cliente**
Comando:
```
aws apigateway get-client-certificates
```
Salida:
```
{
"items": [
{
"pemEncodedCertificate": "-----BEGIN CERTIFICATE----- -----END CERTIFICATE-----",
"clientCertificateId": "a1b2c3",
"expirationDate": 1483556561,
"description": "My Client Certificate",
"createdDate": 1452020561
}
]
}
```
+ Para obtener información sobre la API, consulte [GetClientCertificates](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-client-certificates.html) en la *Referencia de comandos de la AWS CLI*.
### `get-deployment`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-deployment`.
**AWS CLI**
**Para obtener información acerca de una implementación**
Comando:
```
aws apigateway get-deployment --rest-api-id 1234123412 --deployment-id ztt4m2
```
Salida:
```
{
"description": "myDeployment",
"id": "ztt4m2",
"createdDate": 1455218022
}
```
+ Para obtener información sobre la API, consulte [GetDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-deployment.html) en la *Referencia de comandos de la AWS CLI*.
### `get-deployments`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-deployments`.
**AWS CLI**
**Para obtener una lista de implementaciones de una API de REST**
Comando:
```
aws apigateway get-deployments --rest-api-id 1234123412
```
Salida:
```
{
"items": [
{
"createdDate": 1453797217,
"id": "0a2b4c",
"description": "Deployed my API for the first time"
}
]
}
```
+ Para obtener información sobre la API, consulte [GetDeployments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-deployments.html) en la *Referencia de comandos de la AWS CLI*.
### `get-domain-name-access-associations`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-domain-name-access-associations`.
**AWS CLI**
**Ejemplo 1: muestra de todas las asociaciones de acceso a nombres de dominio**
En el siguiente ejemplo de `get-domain-name-access-associations`, se muestran todas las asociaciones de acceso a nombres de dominio.
```
aws apigateway get-domain-name-access-associations
```
Salida:
```
{
"items": [
{
"domainNameAccessAssociationArn": "arn:aws:apigateway:us-west-2:012345678910:/domainnameaccessassociations/domainname/my.private.domain.tld/vpcesource/vpce-abcd1234efg
"accessAssociationSource": "vpce-abcd1234efg",
"accessAssociationSourceType": "VPCE",
"domainNameArn" : "arn:aws:apigateway:us-west-2:111122223333:/domainnames/private.example.com+abcd1234"
}
]
}
```
Para obtener más información, consulte [Nombres de dominio personalizados para las API privadas en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
**Ejemplo 2: muestra de todas las asociaciones de acceso a nombres de dominio que pertenecen a esta cuenta de AWS**
En el siguiente ejemplo de `get-domain-name-access-associations`, se muestran todas las asociaciones de acceso a nombres de dominio que pertenecen a la cuenta de AWS actual.
```
aws apigateway get-domain-name-access-associations \
--resource-owner SELF
```
Salida:
```
{
"items": [
{
"domainNameAccessAssociationArn": "arn:aws:apigateway:us-west-2:012345678910:/domainnameaccessassociations/domainname/my.private.domain.tld/vpcesource/vpce-abcd1234efg
"accessAssociationSource": "vpce-abcd1234efg",
"accessAssociationSourceType": "VPCE",
"domainNameArn" : "arn:aws:apigateway:us-west-2:111122223333:/domainnames/private.example.com+abcd1234"
}
]
}
```
Para obtener más información, consulte [Nombres de dominio personalizados para las API privadas en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
+ Para obtener información sobre la API, consulte [GetDomainNameAccessAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-domain-name-access-associations.html) en la *Referencia del comando de la AWS CLI*.
### `get-domain-name`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-domain-name`.
**AWS CLI**
**Ejemplo 1: obtención de información sobre un nombre de dominio personalizado público**
En el siguiente ejemplo de `get-domain-name`, se obtiene información sobre un nombre de dominio personalizado público.
```
aws apigateway get-domain-name \
--domain-name api.domain.tld
```
Salida:
```
{
"domainName": "api.domain.tld",
"distributionDomainName": "d1a2f3a4c5o6d.cloudfront.net",
"certificateName": "uploadedCertificate",
"certificateUploadDate": 1462565487
}
```
Para obtener más información, consulte [Nombre de dominio personalizado para las API de REST públicas en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
**Ejemplo 2: obtención de información sobre un nombre de dominio personalizado privado**
En el siguiente ejemplo de `get-domain-name`, se obtiene información sobre un nombre de dominio personalizado privado.
```
aws apigateway get-domain-name \
--domain-name api.private.domain.tld \
--domain-name-id abcd1234
```
Salida:
```
{
"domainName": "my.private.domain.tld",
"domainNameId": "abcd1234",
"domainNameArn": "arn:aws:apigateway:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234",
"certificateArn": "arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3",
"certificateUploadDate": "2024-09-10T10:31:20-07:00",
"endpointConfiguration": {
"types": [
"PRIVATE"
]
},
"domainNameStatus": "AVAILABLE",
"securityPolicy": "TLS_1_2",
"policy": "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":\"*\",\"Action\":\"execute-api:Invoke\",\"Resource\":\"arn:aws:execute-api:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234\"},{\"Effect\":\"Deny\",\"Principal\":\"*\",\"Action\":\"execute-api:Invoke\",\"Resource\":\"arn:aws:execute-api:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234\",\"Condition\":{\"StringNotEquals\":{\"aws:SourceVpc\":\"vpc-1a2b3c4d\"}}}]}"
}
```
Para obtener más información, consulte [Nombre de dominio personalizado para las API de REST públicas en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
+ Para obtener información sobre la API, consulte [GetDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-domain-name.html) en la *Referencia de comandos de la AWS CLI*.
### `get-domain-names`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-domain-names`.
**AWS CLI**
**Ejemplo 1: obtención de una lista de nombres de dominio personalizados**
El comando `get-domain-names` siguiente obtiene una lista de nombres de dominio.
```
aws apigateway get-domain-names
```
Salida:
```
{
"items": [
{
"distributionDomainName": "d9511k3l09bkd.cloudfront.net",
"certificateUploadDate": 1452812505,
"certificateName": "my_custom_domain-certificate",
"domainName": "subdomain.domain.tld"
}
]
}
```
Para obtener más información, consulte [Nombres de dominio personalizados para las API privadas en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
**Ejemplo 2: obtención de una lista de nombres de dominio personalizados que pertenecen a esta cuenta de AWS**
El comando `get-domain-names` siguiente obtiene una lista de nombres de dominio que pertenecen a esta cuenta de AWS.
```
aws apigateway get-domain-names \
--resource-owner SELF
```
Salida:
```
{
"items": [
{
"domainName": "my.domain.tld",
"domainNameArn": "arn:aws:apigateway:us-east-1::/domainnames/my.private.domain.tld",
"certificateUploadDate": "2024-08-15T17:02:55-07:00",
"regionalDomainName": "d-abcd1234.execute-api.us-east-1.amazonaws.com",
"regionalHostedZoneId": "Z1UJRXOUMOOFQ8",
"regionalCertificateArn": "arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3",
"endpointConfiguration": {
"types": [
"REGIONAL"
]
},
"domainNameStatus": "AVAILABLE",
"securityPolicy": "TLS_1_2"
},
{
"domainName": "my.private.domain.tld",
"domainNameId": "abcd1234",
"domainNameArn": "arn:aws:apigateway:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234",
"certificateArn": "arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3",
"certificateUploadDate": "2024-11-26T11:44:40-08:00",
"endpointConfiguration": {
"types": [
"PRIVATE"
]
},
"domainNameStatus": "AVAILABLE",
"securityPolicy": "TLS_1_2"
}
]
}
```
Para obtener más información, consulte [Nombres de dominio personalizados para las API privadas en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
**Ejemplo 3: obtención de una lista de nombres de dominio personalizados que pertenecen a otras cuentas de AWS con las que puede crear una asociación de acceso a nombres de dominio.**
El comando `get-domain-names` siguiente obtiene una lista de los nombres de dominio que pertenecen a otras cuentas de AWS a las que tiene acceso para crear una asociación de acceso a nombres de dominio.
```
aws apigateway get-domain-names \
--resource-owner OTHER_ACCOUNTS
```
Salida:
```
{
"items": [
{
"domainName": "my.private.domain.tld",
"domainNameId": "abcd1234",
"domainNameArn": "arn:aws:apigateway:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234"
}
]
}
```
Para obtener más información, consulte [Nombres de dominio personalizados para las API privadas en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
+ Para obtener información sobre la API, consulte [GetDomainNames](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-domain-names.html) en la *Referencia de comandos de la AWS CLI*.
### `get-export`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-export`.
**AWS CLI**
**Para obtener la plantilla Swagger de JSON de una etapa**
Comando:
```
aws apigateway get-export --rest-api-id a1b2c3d4e5 --stage-name dev --export-type swagger /path/to/filename.json
```
**Para obtener la plantilla Swagger de JSON \$1 las extensiones de API Gateway para una etapa**
Comando:
```
aws apigateway get-export --parameters extensions='integrations' --rest-api-id a1b2c3d4e5 --stage-name dev --export-type swagger /path/to/filename.json
```
**Para obtener la plantilla Swagger de JSON \$1 las extensiones de Postman de una etapa**
Comando:
```
aws apigateway get-export --parameters extensions='postman' --rest-api-id a1b2c3d4e5 --stage-name dev --export-type swagger /path/to/filename.json
```
+ Para obtener información sobre la API, consulte [GetExport](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-export.html) en la *Referencia de comandos de la AWS CLI*.
### `get-integration-response`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-integration-response`.
**AWS CLI**
**Para obtener la configuración de la respuesta de integración para un método HTTP definido en un recurso de la API de REST**
Comando:
```
aws apigateway get-integration-response --rest-api-id 1234123412 --resource-id y9h6rt --http-method GET --status-code 200
```
Salida:
```
{
"statusCode": "200",
"responseTemplates": {
"application/json": null
}
}
```
+ Para obtener información sobre la API, consulte [GetIntegrationResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-integration-response.html) en la *Referencia de comandos de la AWS CLI*.
### `get-integration`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-integration`.
**AWS CLI**
**Para obtener la configuración de la integración para un método HTTP definido en un recurso de la API de REST**
Comando:
```
aws apigateway get-integration --rest-api-id 1234123412 --resource-id y9h6rt --http-method GET
```
Salida:
```
{
"httpMethod": "POST",
"integrationResponses": {
"200": {
"responseTemplates": {
"application/json": null
},
"statusCode": "200"
}
},
"cacheKeyParameters": [],
"type": "AWS",
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:My_Function/invocations",
"cacheNamespace": "y9h6rt"
}
```
+ Para obtener información sobre la API, consulte [GetIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-integration.html) en la *Referencia de comandos de la AWS CLI*.
### `get-method-response`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-method-response`.
**AWS CLI**
**Para obtener la configuración del recurso de respuesta de método para un método HTTP definido en un recurso de la API de REST**
Comando:
```
aws apigateway get-method-response --rest-api-id 1234123412 --resource-id y9h6rt --http-method GET --status-code 200
```
Salida:
```
{
"responseModels": {
"application/json": "Empty"
},
"statusCode": "200"
}
```
+ Para obtener información sobre la API, consulte [GetMethodResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-method-response.html) en la *Referencia de comandos de la AWS CLI*.
### `get-method`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-method`.
**AWS CLI**
**Para obtener la configuración del recurso de método para un método HTTP definido en un recurso de la API de REST**
Comando:
```
aws apigateway get-method --rest-api-id 1234123412 --resource-id y9h6rt --http-method GET
```
Salida:
```
{
"apiKeyRequired": false,
"httpMethod": "GET",
"methodIntegration": {
"integrationResponses": {
"200": {
"responseTemplates": {
"application/json": null
},
"statusCode": "200"
}
},
"cacheKeyParameters": [],
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:My_Function/invocations",
"httpMethod": "POST",
"cacheNamespace": "y9h6rt",
"type": "AWS"
},
"requestParameters": {},
"methodResponses": {
"200": {
"responseModels": {
"application/json": "Empty"
},
"statusCode": "200"
}
},
"authorizationType": "NONE"
}
```
+ Para obtener información sobre la API, consulte [GetMethod](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-method.html) en la *Referencia de comandos de la AWS CLI*.
### `get-model-template`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-model-template`.
**AWS CLI**
**Para obtener la plantilla de asignación de un modelo definido en una API de REST**
Comando:
```
aws apigateway get-model-template --rest-api-id 1234123412 --model-name Empty
```
Salida:
```
{
"value": "#set($inputRoot = $input.path('$'))\n{ }"
}
```
+ Para obtener información sobre la API, consulte [GetModelTemplate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-model-template.html) en la *Referencia de comandos de la AWS CLI*.
### `get-model`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-model`.
**AWS CLI**
**Para obtener la configuración de un modelo definido en una API de REST**
Comando:
```
aws apigateway get-model --rest-api-id 1234123412 --model-name Empty
```
Salida:
```
{
"contentType": "application/json",
"description": "This is a default empty schema model",
"name": "Empty",
"id": "etd5w5",
"schema": "{\n \"$schema\": \"http://json-schema.org/draft-04/schema#\",\n \"title\" : \"Empty Schema\",\n \"type\" : \"object\"\n}"
}
```
+ Para obtener información sobre la API, consulte [GetModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-model.html) en la *Referencia de comandos de la AWS CLI*.
### `get-models`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-models`.
**AWS CLI**
**Para obtener una lista de modelos de una API de REST**
Comando:
```
aws apigateway get-models --rest-api-id 1234123412
```
Salida:
```
{
"items": [
{
"description": "This is a default error schema model",
"schema": "{\n \"$schema\" : \"http://json-schema.org/draft-04/schema#\",\n \"title\" : \"Error Schema\",\n \"type\" : \"object\",\n \"properties\" : {\n \"message\" : { \"type\" : \"string\" }\n }\n}",
"contentType": "application/json",
"id": "7tpbze",
"name": "Error"
},
{
"description": "This is a default empty schema model",
"schema": "{\n \"$schema\": \"http://json-schema.org/draft-04/schema#\",\n \"title\" : \"Empty Schema\",\n \"type\" : \"object\"\n}",
"contentType": "application/json",
"id": "etd5w5",
"name": "Empty"
}
]
}
```
+ Para obtener información sobre la API, consulte [GetModels](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-models.html) en la *Referencia de comandos de la AWS CLI*.
### `get-resource`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-resource`.
**AWS CLI**
**Para obtener información sobre un recurso**
Comando:
```
aws apigateway get-resource --rest-api-id 1234123412 --resource-id zwo0y3
```
Salida:
```
{
"path": "/path",
"pathPart": "path",
"id": "zwo0y3",
"parentId": "uyokt6ij2g"
}
```
+ Para obtener detalles sobre la API, consulte [GetResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-resource.html) en la *Referencia de comandos de la AWS CLI*.
### `get-resources`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-resources`.
**AWS CLI**
**Obtención de una lista de recursos para una API de REST**
Comando:
```
aws apigateway get-resources --rest-api-id 1234123412
```
Salida:
```
{
"items": [
{
"path": "/resource/subresource",
"resourceMethods": {
"POST": {}
},
"id": "024ace",
"pathPart": "subresource",
"parentId": "ai5b02"
}
]
}
```
+ Para obtener detalles sobre la API, consulte [GetResources](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-resources.html) en la *Referencia de comandos de la AWS CLI*.
### `get-rest-api`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-rest-api`.
**AWS CLI**
**Para obtener información sobre una API**
Comando:
```
aws apigateway get-rest-api --rest-api-id 1234123412
```
Salida:
```
{
"name": "myAPI",
"id": "o1y243m4f5",
"createdDate": 1453416433
}
```
+ Para obtener información sobre la API, consulte [GetRestApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-rest-api.html) en la *Referencia de comandos de la AWS CLI*.
### `get-rest-apis`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-rest-apis`.
**AWS CLI**
**Para obtener una lista de las API de REST**
Comando:
```
aws apigateway get-rest-apis
```
Salida:
```
{
"items": [
{
"createdDate": 1438884790,
"id": "12s44z21rb",
"name": "My First API"
}
]
}
```
+ Para obtener información sobre la API, consulte [GetRestApis](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-rest-apis.html) en la *Referencia de comandos de la AWS CLI*.
### `get-sdk`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-sdk`.
**AWS CLI**
**Para obtener el SDK para Android de una etapa de API de REST**
Comando:
```
aws apigateway get-sdk --rest-api-id 1234123412 --stage-name dev --sdk-type android --parameters groupId='com.mycompany',invokerPackage='com.mycompany.clientsdk',artifactId='Mycompany-client',artifactVersion='1.0.0' /path/to/android_sdk.zip
```
Salida:
```
{
"contentType": "application/octet-stream",
"contentDisposition": "attachment; filename=\"android_2016-02-22_23-52Z.zip\""
}
```
**Para obtener el SDK para IOS de una etapa de API de REST**
Comando:
```
aws apigateway get-sdk --rest-api-id 1234123412 --stage-name dev --sdk-type objectivec --parameters classPrefix='myprefix' /path/to/iOS_sdk.zip
```
Salida:
```
{
"contentType": "application/octet-stream",
"contentDisposition": "attachment; filename=\"objectivec_2016-02-22_23-52Z.zip\""
}
```
**Para obtener el SDK para Javascript de una etapa de API de REST**
Comando:
```
aws apigateway get-sdk --rest-api-id 1234123412 --stage-name dev --sdk-type javascript /path/to/javascript_sdk.zip
```
Salida:
```
{
"contentType": "application/octet-stream",
"contentDisposition": "attachment; filename=\"javascript_2016-02-22_23-52Z.zip\""
}
```
+ Para obtener información sobre la API, consulte [GetSdk](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-sdk.html) en la *Referencia de comandos de la AWS CLI*.
### `get-stage`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-stage`.
**AWS CLI**
**Para obtener información sobre una etapa de la API**
Comando:
```
aws apigateway get-stage --rest-api-id 1234123412 --stage-name dev
```
Salida:
```
{
"stageName": "dev",
"cacheClusterSize": "0.5",
"cacheClusterEnabled": false,
"cacheClusterStatus": "NOT_AVAILABLE",
"deploymentId": "rbh1fj",
"lastUpdatedDate": 1466802961,
"createdDate": 1460682074,
"methodSettings": {
"*/*": {
"cacheTtlInSeconds": 300,
"loggingLevel": "INFO",
"dataTraceEnabled": false,
"metricsEnabled": true,
"unauthorizedCacheControlHeaderStrategy": "SUCCEED_WITH_RESPONSE_HEADER",
"throttlingRateLimit": 500.0,
"cacheDataEncrypted": false,
"cachingEnabled": false,
"throttlingBurstLimit": 1000,
"requireAuthorizationForCacheControl": true
},
"~1resource/GET": {
"cacheTtlInSeconds": 300,
"loggingLevel": "INFO",
"dataTraceEnabled": false,
"metricsEnabled": true,
"unauthorizedCacheControlHeaderStrategy": "SUCCEED_WITH_RESPONSE_HEADER",
"throttlingRateLimit": 500.0,
"cacheDataEncrypted": false,
"cachingEnabled": false,
"throttlingBurstLimit": 1000,
"requireAuthorizationForCacheControl": true
}
}
}
```
+ Para obtener información sobre la API, consulte [GetStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-stage.html) en la *Referencia de comandos de la AWS CLI*.
### `get-stages`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-stages`.
**AWS CLI**
**Para obtener una lista de etapas de una API de REST**
Comando:
```
aws apigateway get-stages --rest-api-id 1234123412
```
Salida:
```
{
"item": [
{
"stageName": "dev",
"cacheClusterSize": "0.5",
"cacheClusterEnabled": true,
"cacheClusterStatus": "AVAILABLE",
"deploymentId": "123h64",
"lastUpdatedDate": 1456185138,
"createdDate": 1453589092,
"methodSettings": {
"~1resource~1subresource/POST": {
"cacheTtlInSeconds": 300,
"loggingLevel": "INFO",
"dataTraceEnabled": true,
"metricsEnabled": true,
"throttlingRateLimit": 500.0,
"cacheDataEncrypted": false,
"cachingEnabled": false,
"throttlingBurstLimit": 1000
}
}
}
]
}
```
+ Para obtener información sobre la API, consulte [GetStages](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-stages.html) en la *Referencia de comandos de la AWS CLI*.
### `get-usage-plan-key`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-usage-plan-key`.
**AWS CLI**
**Para obtener los detalles de una clave de API asociada a un plan de uso**
Comando:
```
aws apigateway get-usage-plan-key --usage-plan-id a1b2c3 --key-id 1NbjQzMReAkeEQPNAW8r3dXsU2rDD7fc7f2Sipnu
```
+ Para obtener información sobre la API, consulte [GetUsagePlanKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage-plan-key.html) en la *Referencia de comandos de la AWS CLI*.
### `get-usage-plan-keys`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-usage-plan-keys`.
**AWS CLI**
**Para obtener la lista de claves de API asociadas a un plan de uso**
Comando:
```
aws apigateway get-usage-plan-keys --usage-plan-id a1b2c3
```
+ Para obtener información sobre la API, consulte [GetUsagePlanKeys](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage-plan-keys.html) en la *Referencia de comandos de la AWS CLI*.
### `get-usage-plan`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-usage-plan`.
**AWS CLI**
**Para obtener los detalles de un plan de uso**
Comando:
```
aws apigateway get-usage-plan --usage-plan-id a1b2c3
```
+ Para obtener información sobre la API, consulte [GetUsagePlan](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage-plan.html) en la *Referencia de comandos de la AWS CLI*.
### `get-usage-plans`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-usage-plans`.
**AWS CLI**
**Para obtener los detalles de todos los planes de uso**
Comando:
```
aws apigateway get-usage-plans
```
+ Para obtener información sobre la API, consulte [GetUsagePlans](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage-plans.html) en la *Referencia de comandos de la AWS CLI*.
### `get-usage`
En el siguiente ejemplo de código, se muestra cómo utilizar `get-usage`.
**AWS CLI**
**Para obtener los detalles de uso de un plan de uso**
Comando:
```
aws apigateway get-usage --usage-plan-id a1b2c3 --start-date "2016-08-16" --end-date "2016-08-17"
```
+ Para obtener información sobre la API, consulte [GetUsage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage.html) en la *Referencia de comandos de la AWS CLI*.
### `import-rest-api`
En el siguiente ejemplo de código, se muestra cómo utilizar `import-rest-api`.
**AWS CLI**
**Importación de una plantilla Swagger y creación de una API**
Comando:
```
aws apigateway import-rest-api --body 'file:///path/to/API_Swagger_template.json'
```
+ Para obtener información sobre la API, consulte [ImportRestApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/import-rest-api.html) en la *Referencia de comandos de la AWS CLI*.
### `put-integration-response`
En el siguiente ejemplo de código, se muestra cómo utilizar `put-integration-response`.
**AWS CLI**
**Para crear una respuesta de integración como respuesta predeterminada con una plantilla de mapeo definida**
Comando:
```
aws apigateway put-integration-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 200 --selection-pattern "" --response-templates '{"application/json": "{\"json\": \"template\"}"}'
```
**Para crear una respuesta de integración con una expresión regular de 400 y un valor de encabezado definido estáticamente**
Comando:
```
aws apigateway put-integration-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 400 --selection-pattern 400 --response-parameters '{"method.response.header.custom-header": "'"'"'custom-value'"'"'"}'
```
+ Para obtener información sobre la API, consulte [PutIntegrationResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-integration-response.html) en la *Referencia de comandos de la AWS CLI*.
### `put-integration`
En el siguiente ejemplo de código, se muestra cómo utilizar `put-integration`.
**AWS CLI**
**Creación de una solicitud de integración MOCK**
Comando:
```
aws apigateway put-integration --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --type MOCK --request-templates '{ "application/json": "{\"statusCode\": 200}" }'
```
**Para crear una solicitud de integración HTTP**
Comando:
```
aws apigateway put-integration --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --type HTTP --integration-http-method GET --uri 'https://domain.tld/path'
```
**Creación de una solicitud de integración AWS con un punto de conexión de función de Lambda**
Comando:
```
aws apigateway put-integration --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --type AWS --integration-http-method POST --uri 'arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:function_name/invocations'
```
+ Para obtener información acerca de la API, consulte [PutIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-integration.html) en la *Referencia de comandos de la AWS CLI*.
### `put-method-response`
En el siguiente ejemplo de código, se muestra cómo utilizar `put-method-response`.
**AWS CLI**
**Creación de una respuesta de método en el código de estado especificado con un encabezado de respuesta de método personalizado**
Comando:
```
aws apigateway put-method-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 400 --response-parameters "method.response.header.custom-header=false"
```
+ Para obtener información sobre la API, consulta [PutMethodResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method-response.html) en la *Referencia de comandos de la AWS CLI*.
### `put-method`
En el siguiente ejemplo de código, se muestra cómo utilizar `put-method`.
**AWS CLI**
**Para crear un método para un recurso en una API sin autorización, sin clave de API y con un encabezado de solicitud de método personalizado**
Comando:
```
aws apigateway put-method --rest-api-id 1234123412 --resource-id a1b2c3 --http-method PUT --authorization-type "NONE" --no-api-key-required --request-parameters "method.request.header.custom-header=false"
```
+ Para obtener información sobre la API, consulte [PutMethod](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method.html) en la *Referencia de comandos de la AWS CLI*.
### `put-rest-api`
En el siguiente ejemplo de código, se muestra cómo utilizar `put-rest-api`.
**AWS CLI**
**Sobrescritura de una API existente mediante una plantilla de Swagger**
Comando:
```
aws apigateway put-rest-api --rest-api-id 1234123412 --mode overwrite --body 'fileb:///path/to/API_Swagger_template.json'
```
**Combinación de una plantilla de Swagger con una API existente**
Comando:
```
aws apigateway put-rest-api --rest-api-id 1234123412 --mode merge --body 'fileb:///path/to/API_Swagger_template.json'
```
+ Para obtener información sobre la API, consulte [PutRestApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-rest-api.html) en la *Referencia de comandos de la AWS CLI*.
### `reject-domain-name-access-association`
En el siguiente ejemplo de código, se muestra cómo utilizar `reject-domain-name-access-association`.
**AWS CLI**
**Rechazo de una asociación de acceso a nombres de dominio**
En el siguiente ejemplo de `reject-domain-name-access-association`, se rechaza una asociación de acceso a un nombre de dominio entre un nombre de dominio personalizado privado y un punto de conexión de VPC.
```
aws apigateway reject-domain-name-access-association \
--domain-name-access-association-arn arn:aws:apigateway:us-west-2:012345678910:/domainnameaccessassociations/domainname/my.private.domain.tld/vpcesource/vpce-abcd1234efg \
--domain-name-arn arn:aws:apigateway:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234
```
Este comando no genera ninguna salida.
Para obtener más información, consulte [Nombres de dominio personalizados para las API privadas en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
+ Para obtener información sobre la API, consulte [RejectDomainNameAccessAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/reject-domain-name-access-association.html) en la *Referencia de comandos de la AWS CLI*.
### `test-invoke-authorizer`
En el siguiente ejemplo de código, se muestra cómo utilizar `test-invoke-authorizer`.
**AWS CLI**
**Prueba de invocación de una solicitud a un autorizador personalizado que incluya el encabezado y el valor necesarios**
Comando:
```
aws apigateway test-invoke-authorizer --rest-api-id 1234123412 --authorizer-id 5yid1t --headers Authorization='Value'
```
+ Para obtener información sobre la API, consulte [TestInvokeAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/test-invoke-authorizer.html) en la *Referencia de comandos de la AWS CLI*.
### `test-invoke-method`
En el siguiente ejemplo de código, se muestra cómo utilizar `test-invoke-method`.
**AWS CLI**
**Prueba de invocación del recurso raíz en una API mediante una solicitud GET**
Comando:
```
aws apigateway test-invoke-method --rest-api-id 1234123412 --resource-id avl5sg8fw8 --http-method GET --path-with-query-string '/'
```
**Prueba de invocación de un subrecurso en una API mediante una solicitud GET con un valor de parámetro de ruta especificado**
Comando:
```
aws apigateway test-invoke-method --rest-api-id 1234123412 --resource-id 3gapai --http-method GET --path-with-query-string '/pets/1'
```
+ Para obtener información sobre la API, consulte [TestInvokeMethod](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/test-invoke-method.html) en la *Referencia de comandos de la AWS CLI*.
### `update-account`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-account`.
**AWS CLI**
**Cambio del rol de IAM ARN para iniciar sesión en los registros de CloudWatch**
Comando:
```
aws apigateway update-account --patch-operations op='replace',path='/cloudwatchRoleArn',value='arn:aws:iam::123412341234:role/APIGatewayToCloudWatchLogs'
```
Salida:
```
{
"cloudwatchRoleArn": "arn:aws:iam::123412341234:role/APIGatewayToCloudWatchLogs",
"throttleSettings": {
"rateLimit": 1000.0,
"burstLimit": 2000
}
}
```
+ Para obtener información sobre la API, consulte [UpdateAccount](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-account.html) en la *Referencia de comandos de la AWS CLI*.
### `update-api-key`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-api-key`.
**AWS CLI**
**Cambio del nombre de una clave de API**
Comando:
```
aws apigateway update-api-key --api-key sNvjQDMReA1eEQPNAW8r37XsU2rDD7fc7m2SiMnu --patch-operations op='replace',path='/name',value='newName'
```
Salida:
```
{
"description": "currentDescription",
"enabled": true,
"stageKeys": [
"41t2j324r5/dev"
],
"lastUpdatedDate": 1470086052,
"createdDate": 1445460347,
"id": "sNvjQDMReA1vEQPNzW8r3dXsU2rrD7fcjm2SiMnu",
"name": "newName"
}
```
**Deshabilitación de la clave de API**
Comando:
```
aws apigateway update-api-key --api-key sNvjQDMReA1eEQPNAW8r37XsU2rDD7fc7m2SiMnu --patch-operations op='replace',path='/enabled',value='false'
```
Salida:
```
{
"description": "currentDescription",
"enabled": false,
"stageKeys": [
"41t2j324r5/dev"
],
"lastUpdatedDate": 1470086052,
"createdDate": 1445460347,
"id": "sNvjQDMReA1vEQPNzW8r3dXsU2rrD7fcjm2SiMnu",
"name": "newName"
}
```
+ Para obtener información sobre la API, consulte [UpdateApiKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-api-key.html) en la *Referencia de comandos de la AWS CLI*.
### `update-authorizer`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-authorizer`.
**AWS CLI**
**Cambio del nombre del autorizador personalizado**
Comando:
```
aws apigateway update-authorizer --rest-api-id 1234123412 --authorizer-id gfi4n3 --patch-operations op='replace',path='/name',value='testAuthorizer'
```
Salida:
```
{
"authType": "custom",
"name": "testAuthorizer",
"authorizerUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:customAuthorizer/invocations",
"authorizerResultTtlInSeconds": 300,
"identitySource": "method.request.header.Authorization",
"type": "TOKEN",
"id": "gfi4n3"
}
```
**Cambio de la función de Lambda que invoca el autorizador personalizado**
Comando:
```
aws apigateway update-authorizer --rest-api-id 1234123412 --authorizer-id gfi4n3 --patch-operations op='replace',path='/authorizerUri',value='arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:newAuthorizer/invocations'
```
Salida:
```
{
"authType": "custom",
"name": "testAuthorizer",
"authorizerUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:newAuthorizer/invocations",
"authorizerResultTtlInSeconds": 300,
"identitySource": "method.request.header.Authorization",
"type": "TOKEN",
"id": "gfi4n3"
}
```
+ Para obtener información sobre la API, consulte [UpdateAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-authorizer.html) en la *Referencia de comandos de la AWS CLI*.
### `update-base-path-mapping`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-base-path-mapping`.
**AWS CLI**
**Para cambiar la ruta base de un nombre de dominio personalizado**
Comando:
```
aws apigateway update-base-path-mapping --domain-name api.domain.tld --base-path prod --patch-operations op='replace',path='/basePath',value='v1'
```
Salida:
```
{
"basePath": "v1",
"restApiId": "1234123412",
"stage": "api"
}
```
+ Para obtener información sobre la API, consulte [UpdateBasePathMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-base-path-mapping.html) en la *Referencia de comandos de la AWS CLI*.
### `update-client-certificate`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-client-certificate`.
**AWS CLI**
**Actualización de la descripción de un certificado de cliente**
Comando:
```
aws apigateway update-client-certificate --client-certificate-id a1b2c3 --patch-operations op='replace',path='/description',value='My new description'
```
+ Para obtener información sobre la API, consulte [UpdateClientCertificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-client-certificate.html) en la *Referencia de comandos de la AWS CLI*.
### `update-deployment`
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**
Comando:
```
aws apigateway update-deployment --rest-api-id 1234123412 --deployment-id ztt4m2 --patch-operations op='replace',path='/description',value='newDescription'
```
Salida:
```
{
"description": "newDescription",
"id": "ztt4m2",
"createdDate": 1455218022
}
```
+ Para obtener más información sobre la API, consulte [UpdateDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-deployment.html) en la *Referencia de comandos de la AWS CLI*.
### `update-domain-name`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-domain-name`.
**AWS CLI**
**Cambio del nombre de certificado de un dominio personalizado**
En el siguiente ejemplo de `update-domain-name`, se cambia el nombre de certificado de un dominio personalizado.
```
aws apigateway update-domain-name \
--domain-name api.domain.tld \
--patch-operations op='replace',path='/certificateArn',value='arn:aws:acm:us-west-2:111122223333:certificate/CERTEXAMPLE123EXAMPLE'
```
Salida:
```
{
"domainName": "api.domain.tld",
"distributionDomainName": "d123456789012.cloudfront.net",
"certificateArn": "arn:aws:acm:us-west-2:111122223333:certificate/CERTEXAMPLE123EXAMPLE",
"certificateUploadDate": 1462565487
}
```
Para obtener más información, consulte [Nombre de dominio personalizado para las API de REST en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) en la *Guía para desarrolladores de Amazon API Gateway*.
+ Para obtener información sobre la API, consulte [UpdateDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-domain-name.html) en la *Referencia de comandos de la AWS CLI*.
### `update-integration-response`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-integration-response`.
**AWS CLI**
**Cambio del encabezado de una respuesta de integración para que tenga una asignación estática de '\$1'**
Comando:
```
aws apigateway update-integration-response --rest-api-id 1234123412 --resource-id 3gapai --http-method GET --status-code 200 --patch-operations op='replace',path='/responseParameters/method.response.header.Access-Control-Allow-Origin',value='"'"'*'"'"'
```
Salida:
```
{
"statusCode": "200",
"responseParameters": {
"method.response.header.Access-Control-Allow-Origin": "'*'"
}
}
```
**Eliminación de un encabezado de respuesta de integración**
Comando:
```
aws apigateway update-integration-response --rest-api-id 1234123412 --resource-id 3gapai --http-method GET --status-code 200 --patch-operations op='remove',path='/responseParameters/method.response.header.Access-Control-Allow-Origin'
```
+ Para obtener información sobre la API, consulte [UpdateIntegrationResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-integration-response.html) en la *Referencia de comandos de la AWS CLI*.
### `update-integration`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-integration`.
**AWS CLI**
**Adición de la plantilla de asignación Content-Type: application/json configurada con Input Passthrough**
Comando:
```
aws apigateway update-integration \
--rest-api-id a1b2c3d4e5 \
--resource-id a1b2c3 \
--http-method POST \
--patch-operations "op='add',path='/requestTemplates/application~1json'"
```
**Actualización (sustitución) de la plantilla de asignación Content-Type: application/json configurada con una plantilla personalizada**
Comando:
```
aws apigateway update-integration \
--rest-api-id a1b2c3d4e5 \
--resource-id a1b2c3 \
--http-method POST \
--patch-operations "op='replace',path='/requestTemplates/application~1json',value='{"example": "json"}'"
```
**Actualización (sustitución) de una plantilla personalizada asociada a Content-Type: application/json con Input Passthrough**
Comando:
```
aws apigateway update-integration \
--rest-api-id a1b2c3d4e5 \
--resource-id a1b2c3 \
--http-method POST \
--patch-operations "op='replace',path='requestTemplates/application~1json'"
```
**Eliminación de la plantilla de asignación Content-Type: application/json**
Comando:
```
aws apigateway update-integration \
--rest-api-id a1b2c3d4e5 \
--resource-id a1b2c3 \
--http-method POST \
--patch-operations "op='remove',path='/requestTemplates/application~1json'"
```
+ Para obtener información sobre la API, consulte [UpdateIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-integration.html) en la *Referencia de comandos de la AWS CLI*.
### `update-method-response`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-method-response`.
**AWS CLI**
**Creación de un nuevo encabezado de respuesta de método para la respuesta 200 en un método y definición como no obligatorio (predeterminado)**
Comando:
```
aws apigateway update-method-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 200 --patch-operations op="add",path="/responseParameters/method.response.header.custom-header",value="false"
```
**Eliminación de un modelo de respuesta de la respuesta 200 en un método**
Comando:
```
aws apigateway update-method-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 200 --patch-operations op="remove",path="/responseModels/application~1json"
```
+ Para obtener información sobre la API, consulte [UpdateMethodResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-method-response.html) en la *Referencia de comandos de la AWS CLI*.
### `update-method`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-method`.
**AWS CLI**
**Ejemplo 1: cómo modificar un método para que exija una clave de API**
En el siguiente ejemplo de `update-method`, se modifica el método para que exija una clave de API.
```
aws apigateway update-method \
--rest-api-id 1234123412 \
--resource-id a1b2c3 \
--http-method GET \
--patch-operations op="replace",path="/apiKeyRequired",value="true"
```
Salida:
```
{
"httpMethod": "GET",
"authorizationType": "NONE",
"apiKeyRequired": true,
"methodResponses": {
"200": {
"statusCode": "200",
"responseModels": {}
}
},
"methodIntegration": {
"type": "AWS",
"httpMethod": "POST",
"uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789111:function:hello-world/invocations",
"passthroughBehavior": "WHEN_NO_MATCH",
"contentHandling": "CONVERT_TO_TEXT",
"timeoutInMillis": 29000,
"cacheNamespace": "h7i8j9",
"cacheKeyParameters": [],
"integrationResponses": {
"200": {
"statusCode": "200",
"responseTemplates": {}
}
}
}
}
```
**Ejemplo 2: cómo modificar un método para que exija una autorización de IAM**
En el siguiente ejemplo de `update-method`, se modifica el método para que exija una autorización de IAM.
```
aws apigateway update-method \
--rest-api-id 1234123412 \
--resource-id a1b2c3 \
--http-method GET \
--patch-operations op="replace",path="/authorizationType",value="AWS_IAM"
```
Salida:
```
{
"httpMethod": "GET",
"authorizationType": "AWS_IAM",
"apiKeyRequired": false,
"methodResponses": {
"200": {
"statusCode": "200",
"responseModels": {}
}
},
"methodIntegration": {
"type": "AWS",
"httpMethod": "POST",
"uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789111:function:hello-world/invocations",
"passthroughBehavior": "WHEN_NO_MATCH",
"contentHandling": "CONVERT_TO_TEXT",
"timeoutInMillis": 29000,
"cacheNamespace": "h7i8j9",
"cacheKeyParameters": [],
"integrationResponses": {
"200": {
"statusCode": "200",
"responseTemplates": {}
}
}
}
}
```
**Ejemplo 3: cómo modificar un método para que exija una autorización de Lambda**
En el siguiente ejemplo de `update-method`, se modifica el método para que exija una autorización de Lambda.
```
aws apigateway update-method --rest-api-id 1234123412 \
--resource-id a1b2c3 \
--http-method GET \
--patch-operations op="replace",path="/authorizationType",value="CUSTOM" op="replace",path="/authorizerId",value="e4f5g6"
```
Salida:
```
{
"httpMethod": "GET",
"authorizationType": "CUSTOM",
"authorizerId" : "e4f5g6",
"apiKeyRequired": false,
"methodResponses": {
"200": {
"statusCode": "200",
"responseModels": {}
}
},
"methodIntegration": {
"type": "AWS",
"httpMethod": "POST",
"uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789111:function:hello-world/invocations",
"passthroughBehavior": "WHEN_NO_MATCH",
"contentHandling": "CONVERT_TO_TEXT",
"timeoutInMillis": 29000,
"cacheNamespace": "h7i8j9",
"cacheKeyParameters": [],
"integrationResponses": {
"200": {
"statusCode": "200",
"responseTemplates": {}
}
}
}
}
```
Para obtener más información, consulte [Creación, configuración y prueba de planes de uso con la CLI y la API de REST de API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-create-usage-plans-with-rest-api.html) y [Control y administración del acceso a las API de REST en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-to-api.html) en la *Guía para desarrolladores de Amazon API Gateway*.
+ Para obtener información sobre la API, consulte [UpdateMethod](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-method.html) en la *Referencia de comandos de la AWS CLI*.
### `update-model`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-model`.
**AWS CLI**
**Cambio de la descripción de un modelo en una API**
Comando:
```
aws apigateway update-model --rest-api-id 1234123412 --model-name 'Empty' --patch-operations op=replace,path=/description,value='New Description'
```
**Cambio del esquema de un modelo en una API**
Comando:
```
aws apigateway update-model --rest-api-id 1234123412 --model-name 'Empty' --patch-operations op=replace,path=/schema,value='"{ \"$schema\": \"http://json-schema.org/draft-04/schema#\", \"title\" : \"Empty Schema\", \"type\" : \"object\" }"'
```
+ Para obtener información sobre la API, consulte [UpdateModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-model.html) en la *Referencia de comandos de la AWS CLI*.
### `update-resource`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-resource`.
**AWS CLI**
**Desplazamiento y colocación de un recurso en un recurso principal distinto de una API**
Comando:
```
aws apigateway update-resource --rest-api-id 1234123412 --resource-id 1a2b3c --patch-operations op=replace,path=/parentId,value='3c2b1a'
```
Salida:
```
{
"path": "/resource",
"pathPart": "resource",
"id": "1a2b3c",
"parentId": "3c2b1a"
}
```
**Cambio del nombre de un recurso (pathPart) en una API**
Comando:
```
aws apigateway update-resource --rest-api-id 1234123412 --resource-id 1a2b3c --patch-operations op=replace,path=/pathPart,value=newresourcename
```
Salida:
```
{
"path": "/newresourcename",
"pathPart": "newresourcename",
"id": "1a2b3c",
"parentId": "3c2b1a"
}
```
+ Para obtener información sobre la API, consulte [UpdateResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-resource.html) en la *Referencia de comandos de la AWS CLI*.
### `update-rest-api`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-rest-api`.
**AWS CLI**
**Cambio del nombre de una API**
Comando:
```
aws apigateway update-rest-api --rest-api-id 1234123412 --patch-operations op=replace,path=/name,value='New Name'
```
**Cambio de la descripción de una API**
Comando:
```
aws apigateway update-rest-api --rest-api-id 1234123412 --patch-operations op=replace,path=/description,value='New Description'
```
+ Para obtener información sobre la API, consulte [UpdateRestApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-rest-api.html) en la *Referencia de comandos de la AWS CLI*.
### `update-stage`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-stage`.
**AWS CLI**
**Ejemplo 1: cómo anular la configuración de etapa de un recurso y un método**
En el siguiente ejemplo de `update-stage`, se anula la configuración de etapa y se desactiva el registro completo de solicitudes y respuestas de un recurso y un método específicos.
```
aws apigateway update-stage \
--rest-api-id 1234123412 \
--stage-name 'dev' \
--patch-operations op=replace,path=/~1resourceName/GET/logging/dataTrace,value=false
```
Salida:
```
{
"deploymentId": "5ubd17",
"stageName": "dev",
"cacheClusterEnabled": false,
"cacheClusterStatus": "NOT_AVAILABLE",
"methodSettings": {
"~1resourceName/GET": {
"metricsEnabled": false,
"dataTraceEnabled": false,
"throttlingBurstLimit": 5000,
"throttlingRateLimit": 10000.0,
"cachingEnabled": false,
"cacheTtlInSeconds": 300,
"cacheDataEncrypted": false,
"requireAuthorizationForCacheControl": true,
"unauthorizedCacheControlHeaderStrategy": "SUCCEED_WITH_RESPONSE_HEADER"
}
},
"tracingEnabled": false,
"createdDate": "2022-07-18T10:11:18-07:00",
"lastUpdatedDate": "2022-07-18T10:19:04-07:00"
}
```
Para obtener más información, consulte [Configuración de una etapa para una API de REST en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-stages.html) en la *Guía para desarrolladores de Amazon API Gateway*.
**Ejemplo 2: cómo actualizar la configuración de etapa de todos los recursos y métodos de una etapa de API**
En el siguiente ejemplo de `update-stage`, se activa el registro completo de solicitudes y respuestas de todos los recursos y métodos de una etapa de API.
```
aws apigateway update-stage \
--rest-api-id 1234123412 \
--stage-name 'dev' \
--patch-operations 'op=replace,path=/*/*/logging/dataTrace,value=true'
```
Salida:
```
{
"deploymentId": "5ubd17",
"stageName": "dev",
"cacheClusterEnabled": false,
"cacheClusterStatus": "NOT_AVAILABLE",
"methodSettings": {
"*/*": {
"metricsEnabled": false,
"dataTraceEnabled": true,
"throttlingBurstLimit": 5000,
"throttlingRateLimit": 10000.0,
"cachingEnabled": false,
"cacheTtlInSeconds": 300,
"cacheDataEncrypted": false,
"requireAuthorizationForCacheControl": true,
"unauthorizedCacheControlHeaderStrategy": "SUCCEED_WITH_RESPONSE_HEADER"
}
},
"tracingEnabled": false,
"createdDate": "2022-07-18T10:11:18-07:00",
"lastUpdatedDate": "2022-07-18T10:31:04-07:00"
}
```
Para obtener más información, consulte [Configuración de una etapa para una API de REST en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-stages.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/apigateway/update-stage.html) en la *Referencia de comandos de la AWS CLI*.
### `update-usage-plan`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-usage-plan`.
**AWS CLI**
**Cambio del período definido en un plan de uso**
Comando:
```
aws apigateway update-usage-plan --usage-plan-id a1b2c3 --patch-operations op="replace",path="/quota/period",value="MONTH"
```
**Cambio del límite de cuota definido en un plan de uso**
Comando:
```
aws apigateway update-usage-plan --usage-plan-id a1b2c3 --patch-operations op="replace",path="/quota/limit",value="500"
```
**Cambio del límite de tasa de limitación definido en un plan de uso**
Comando:
```
aws apigateway update-usage-plan --usage-plan-id a1b2c3 --patch-operations op="replace",path="/throttle/rateLimit",value="10"
```
**Cambio del límite de ráfaga de limitación definido en un plan de uso**
Comando:
```
aws apigateway update-usage-plan --usage-plan-id a1b2c3 --patch-operations op="replace",path="/throttle/burstLimit",value="20"
```
+ Para obtener más información sobre la API, consulte [UpdateUsagePlan](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-usage-plan.html) en la *Referencia de comandos de la AWS CLI*.
### `update-usage`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-usage`.
**AWS CLI**
**Modificación temporal de la cuota de una clave de API durante el período actual definido en el plan de uso**
Comando:
```
aws apigateway update-usage --usage-plan-id a1b2c3 --key-id 1NbjQzMReAkeEQPNAW8r3dXsU2rDD7fc7f2Sipnu --patch-operations op="replace",path="/remaining",value="50"
```
+ Para obtener información sobre la API, consulte [UpdateUsage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-usage.html) en la *Referencia de comandos de la AWS CLI*.
### `update-vpc-link`
En el siguiente ejemplo de código, se muestra cómo utilizar `update-vpc-link`.
**AWS CLI**
**Ejemplo 1: Para actualizar el nombre de un enlace de VPC existente**
En el ejemplo de `update-vpc-link` siguiente, se actualiza el nombre del enlace de la VPC especificado.
```
aws apigateway update-vpc-link \
--vpc-link-id ab3de6 \
--patch-operations op=replace,path=/name,value=my-vpc-link
```
Salida:
```
{
"id": "ab3de6",
"name": "my-vpc-link",
"targetArns": [
"arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/net/my-lb/12a456s89aaa12345"
],
"status": "AVAILABLE",
"statusMessage": "Your vpc link is ready for use",
"tags": {}
}
```
Para obtener más información, consulte [Actualización del enlace de la VPC existente](https://docs.aws.amazon.com/cli/latest/reference/apigateway/update-vpc-link.html) en la *Referencia de comandos de la CLI de AWS*.
**Ejemplo 2: Para actualizar el nombre y la descripción de un enlace de VPC existente**
En el ejemplo de `update-vpc-link` siguiente, se actualiza el nombre del enlace de la VPC especificado.
```
aws apigateway update-vpc-link \
--vpc-link-id ab3de6 \
--patch-operations op=replace,path=/name,value=my-vpc-link op=replace,path=/description,value="My custom description"
```
Salida:
```
{
"id": "ab3de6",
"name": "my-vpc-link",
"description": "My custom description",
"targetArns": [
"arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/net/my-lb/12a456s89aaa12345"
],
"status": "AVAILABLE",
"statusMessage": "Your vpc link is ready for use",
"tags": {}
}
```
Para obtener más información, consulte [Actualización del enlace de la VPC existente](https://docs.aws.amazon.com/cli/latest/reference/apigateway/update-vpc-link.html) en la *Referencia de comandos de la CLI de AWS*.
+ Para obtener información sobre la API, consulte [UpdateVpcLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-vpc-link.html) en la *Referencia de comandos de la AWS CLI*.