Sono disponibili altri esempi AWS SDK nel repository [AWS Doc SDK](https://github.com/awsdocs/aws-doc-sdk-examples) Examples. GitHub
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esempi per Gateway API con SDK per Python (Boto3)
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per Python (Boto3) with API Gateway.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
*Scenari*: esempi di codice che mostrano come eseguire un’attività specifica chiamando più funzioni all’interno dello stesso servizio o combinate con altri Servizi AWS.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
+ [Scenari](#scenarios)
## Azioni
### `CreateDeployment`
Il seguente esempio di codice mostra come utilizzare`CreateDeployment`.
**SDK per Python (Boto3)**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
```
class ApiGatewayToService:
"""
Encapsulates Amazon API Gateway functions that are used to create a REST API that
integrates with another AWS service.
"""
def __init__(self, apig_client):
"""
:param apig_client: A Boto3 API Gateway client.
"""
self.apig_client = apig_client
self.api_id = None
self.root_id = None
self.stage = None
def deploy_api(self, stage_name):
"""
Deploys a REST API. After a REST API is deployed, it can be called from any
REST client, such as the Python Requests package or Postman.
:param stage_name: The stage of the API to deploy, such as 'test'.
:return: The base URL of the deployed REST API.
"""
try:
self.apig_client.create_deployment(
restApiId=self.api_id, stageName=stage_name
)
self.stage = stage_name
logger.info("Deployed stage %s.", stage_name)
except ClientError:
logger.exception("Couldn't deploy stage %s.", stage_name)
raise
else:
return self.api_url()
def api_url(self, resource=None):
"""
Builds the REST API URL from its parts.
:param resource: The resource path to append to the base URL.
:return: The REST URL to the specified resource.
"""
url = (
f"https://{self.api_id}.execute-api.{self.apig_client.meta.region_name}"
f".amazonaws.com/{self.stage}"
)
if resource is not None:
url = f"{url}/{resource}"
return url
```
+ Per i dettagli sull'API, consulta [CreateDeployment AWS](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/CreateDeployment)*SDK for Python (Boto3) API Reference*.
### `CreateResource`
Il seguente esempio di codice mostra come utilizzare. `CreateResource`
**SDK per Python (Boto3)**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
```
class ApiGatewayToService:
"""
Encapsulates Amazon API Gateway functions that are used to create a REST API that
integrates with another AWS service.
"""
def __init__(self, apig_client):
"""
:param apig_client: A Boto3 API Gateway client.
"""
self.apig_client = apig_client
self.api_id = None
self.root_id = None
self.stage = None
def add_rest_resource(self, parent_id, resource_path):
"""
Adds a resource to a REST API.
:param parent_id: The ID of the parent resource.
:param resource_path: The path of the new resource, relative to the parent.
:return: The ID of the new resource.
"""
try:
result = self.apig_client.create_resource(
restApiId=self.api_id, parentId=parent_id, pathPart=resource_path
)
resource_id = result["id"]
logger.info("Created resource %s.", resource_path)
except ClientError:
logger.exception("Couldn't create resource %s.", resource_path)
raise
else:
return resource_id
```
+ Per i dettagli sull'API, consulta [CreateResource AWS](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/CreateResource)*SDK for Python (Boto3) API Reference*.
### `CreateRestApi`
Il seguente esempio di codice mostra come utilizzare. `CreateRestApi`
**SDK per Python (Boto3)**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
```
class ApiGatewayToService:
"""
Encapsulates Amazon API Gateway functions that are used to create a REST API that
integrates with another AWS service.
"""
def __init__(self, apig_client):
"""
:param apig_client: A Boto3 API Gateway client.
"""
self.apig_client = apig_client
self.api_id = None
self.root_id = None
self.stage = None
def create_rest_api(self, api_name):
"""
Creates a REST API on API Gateway. The default API has only a root resource
and no HTTP methods.
:param api_name: The name of the API. This descriptive name is not used in
the API path.
:return: The ID of the newly created API.
"""
try:
result = self.apig_client.create_rest_api(name=api_name)
self.api_id = result["id"]
logger.info("Created REST API %s with ID %s.", api_name, self.api_id)
except ClientError:
logger.exception("Couldn't create REST API %s.", api_name)
raise
try:
result = self.apig_client.get_resources(restApiId=self.api_id)
self.root_id = next(
item for item in result["items"] if item["path"] == "/"
)["id"]
except ClientError:
logger.exception("Couldn't get resources for API %s.", self.api_id)
raise
except StopIteration as err:
logger.exception("No root resource found in API %s.", self.api_id)
raise ValueError from err
return self.api_id
```
+ Per i dettagli sull'API, consulta [CreateRestApi AWS](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/CreateRestApi)*SDK for Python (Boto3) API Reference*.
### `DeleteRestApi`
Il seguente esempio di codice mostra come utilizzare. `DeleteRestApi`
**SDK per Python (Boto3)**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
```
class ApiGatewayToService:
"""
Encapsulates Amazon API Gateway functions that are used to create a REST API that
integrates with another AWS service.
"""
def __init__(self, apig_client):
"""
:param apig_client: A Boto3 API Gateway client.
"""
self.apig_client = apig_client
self.api_id = None
self.root_id = None
self.stage = None
def delete_rest_api(self):
"""
Deletes a REST API, including all of its resources and configuration.
"""
try:
self.apig_client.delete_rest_api(restApiId=self.api_id)
logger.info("Deleted REST API %s.", self.api_id)
self.api_id = None
except ClientError:
logger.exception("Couldn't delete REST API %s.", self.api_id)
raise
```
+ Per i dettagli sull'API, consulta [DeleteRestApi AWS](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/DeleteRestApi)*SDK for Python (Boto3) API Reference*.
### `GetResources`
Il seguente esempio di codice mostra come utilizzare. `GetResources`
**SDK per Python (Boto3)**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
```
class ApiGatewayToService:
"""
Encapsulates Amazon API Gateway functions that are used to create a REST API that
integrates with another AWS service.
"""
def __init__(self, apig_client):
"""
:param apig_client: A Boto3 API Gateway client.
"""
self.apig_client = apig_client
self.api_id = None
self.root_id = None
self.stage = None
def create_rest_api(self, api_name):
"""
Creates a REST API on API Gateway. The default API has only a root resource
and no HTTP methods.
:param api_name: The name of the API. This descriptive name is not used in
the API path.
:return: The ID of the newly created API.
"""
try:
result = self.apig_client.create_rest_api(name=api_name)
self.api_id = result["id"]
logger.info("Created REST API %s with ID %s.", api_name, self.api_id)
except ClientError:
logger.exception("Couldn't create REST API %s.", api_name)
raise
try:
result = self.apig_client.get_resources(restApiId=self.api_id)
self.root_id = next(
item for item in result["items"] if item["path"] == "/"
)["id"]
except ClientError:
logger.exception("Couldn't get resources for API %s.", self.api_id)
raise
except StopIteration as err:
logger.exception("No root resource found in API %s.", self.api_id)
raise ValueError from err
return self.api_id
```
+ Per i dettagli sull'API, consulta [GetResources AWS](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/GetResources)*SDK for Python (Boto3) API Reference*.
### `GetRestApis`
Il seguente esempio di codice mostra come utilizzare. `GetRestApis`
**SDK per Python (Boto3)**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
```
class ApiGatewayToService:
"""
Encapsulates Amazon API Gateway functions that are used to create a REST API that
integrates with another AWS service.
"""
def __init__(self, apig_client):
"""
:param apig_client: A Boto3 API Gateway client.
"""
self.apig_client = apig_client
self.api_id = None
self.root_id = None
self.stage = None
def get_rest_api_id(self, api_name):
"""
Gets the ID of a REST API from its name by searching the list of REST APIs
for the current account. Because names need not be unique, this returns only
the first API with the specified name.
:param api_name: The name of the API to look up.
:return: The ID of the specified API.
"""
try:
rest_api = None
paginator = self.apig_client.get_paginator("get_rest_apis")
for page in paginator.paginate():
rest_api = next(
(item for item in page["items"] if item["name"] == api_name), None
)
if rest_api is not None:
break
self.api_id = rest_api["id"]
logger.info("Found ID %s for API %s.", rest_api["id"], api_name)
except ClientError:
logger.exception("Couldn't find ID for API %s.", api_name)
raise
else:
return rest_api["id"]
```
+ Per i dettagli sull'API, consulta [GetRestApis AWS](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/GetRestApis)*SDK for Python (Boto3) API Reference*.
### `PutIntegration`
Il seguente esempio di codice mostra come utilizzare. `PutIntegration`
**SDK per Python (Boto3)**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
```
class ApiGatewayToService:
"""
Encapsulates Amazon API Gateway functions that are used to create a REST API that
integrates with another AWS service.
"""
def __init__(self, apig_client):
"""
:param apig_client: A Boto3 API Gateway client.
"""
self.apig_client = apig_client
self.api_id = None
self.root_id = None
self.stage = None
def add_integration_method(
self,
resource_id,
rest_method,
service_endpoint_prefix,
service_action,
service_method,
role_arn,
mapping_template,
):
"""
Adds an integration method to a REST API. An integration method is a REST
resource, such as '/users', and an HTTP verb, such as GET. The integration
method is backed by an AWS service, such as Amazon DynamoDB.
:param resource_id: The ID of the REST resource.
:param rest_method: The HTTP verb used with the REST resource.
:param service_endpoint_prefix: The service endpoint that is integrated with
this method, such as 'dynamodb'.
:param service_action: The action that is called on the service, such as
'GetItem'.
:param service_method: The HTTP method of the service request, such as POST.
:param role_arn: The Amazon Resource Name (ARN) of a role that grants API
Gateway permission to use the specified action with the
service.
:param mapping_template: A mapping template that is used to translate REST
elements, such as query parameters, to the request
body format required by the service.
"""
service_uri = (
f"arn:aws:apigateway:{self.apig_client.meta.region_name}"
f":{service_endpoint_prefix}:action/{service_action}"
)
try:
self.apig_client.put_method(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
authorizationType="NONE",
)
self.apig_client.put_method_response(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
statusCode="200",
responseModels={"application/json": "Empty"},
)
logger.info("Created %s method for resource %s.", rest_method, resource_id)
except ClientError:
logger.exception(
"Couldn't create %s method for resource %s.", rest_method, resource_id
)
raise
try:
self.apig_client.put_integration(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
type="AWS",
integrationHttpMethod=service_method,
credentials=role_arn,
requestTemplates={"application/json": json.dumps(mapping_template)},
uri=service_uri,
passthroughBehavior="WHEN_NO_TEMPLATES",
)
self.apig_client.put_integration_response(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
statusCode="200",
responseTemplates={"application/json": ""},
)
logger.info(
"Created integration for resource %s to service URI %s.",
resource_id,
service_uri,
)
except ClientError:
logger.exception(
"Couldn't create integration for resource %s to service URI %s.",
resource_id,
service_uri,
)
raise
```
+ Per i dettagli sull'API, consulta [PutIntegration AWS](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/PutIntegration)*SDK for Python (Boto3) API Reference*.
### `PutIntegrationResponse`
Il seguente esempio di codice mostra come utilizzare. `PutIntegrationResponse`
**SDK per Python (Boto3)**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
```
class ApiGatewayToService:
"""
Encapsulates Amazon API Gateway functions that are used to create a REST API that
integrates with another AWS service.
"""
def __init__(self, apig_client):
"""
:param apig_client: A Boto3 API Gateway client.
"""
self.apig_client = apig_client
self.api_id = None
self.root_id = None
self.stage = None
def add_integration_method(
self,
resource_id,
rest_method,
service_endpoint_prefix,
service_action,
service_method,
role_arn,
mapping_template,
):
"""
Adds an integration method to a REST API. An integration method is a REST
resource, such as '/users', and an HTTP verb, such as GET. The integration
method is backed by an AWS service, such as Amazon DynamoDB.
:param resource_id: The ID of the REST resource.
:param rest_method: The HTTP verb used with the REST resource.
:param service_endpoint_prefix: The service endpoint that is integrated with
this method, such as 'dynamodb'.
:param service_action: The action that is called on the service, such as
'GetItem'.
:param service_method: The HTTP method of the service request, such as POST.
:param role_arn: The Amazon Resource Name (ARN) of a role that grants API
Gateway permission to use the specified action with the
service.
:param mapping_template: A mapping template that is used to translate REST
elements, such as query parameters, to the request
body format required by the service.
"""
service_uri = (
f"arn:aws:apigateway:{self.apig_client.meta.region_name}"
f":{service_endpoint_prefix}:action/{service_action}"
)
try:
self.apig_client.put_method(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
authorizationType="NONE",
)
self.apig_client.put_method_response(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
statusCode="200",
responseModels={"application/json": "Empty"},
)
logger.info("Created %s method for resource %s.", rest_method, resource_id)
except ClientError:
logger.exception(
"Couldn't create %s method for resource %s.", rest_method, resource_id
)
raise
try:
self.apig_client.put_integration(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
type="AWS",
integrationHttpMethod=service_method,
credentials=role_arn,
requestTemplates={"application/json": json.dumps(mapping_template)},
uri=service_uri,
passthroughBehavior="WHEN_NO_TEMPLATES",
)
self.apig_client.put_integration_response(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
statusCode="200",
responseTemplates={"application/json": ""},
)
logger.info(
"Created integration for resource %s to service URI %s.",
resource_id,
service_uri,
)
except ClientError:
logger.exception(
"Couldn't create integration for resource %s to service URI %s.",
resource_id,
service_uri,
)
raise
```
+ Per i dettagli sull'API, consulta [PutIntegrationResponse AWS](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/PutIntegrationResponse)*SDK for Python (Boto3) API Reference*.
### `PutMethod`
Il seguente esempio di codice mostra come utilizzare. `PutMethod`
**SDK per Python (Boto3)**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
```
class ApiGatewayToService:
"""
Encapsulates Amazon API Gateway functions that are used to create a REST API that
integrates with another AWS service.
"""
def __init__(self, apig_client):
"""
:param apig_client: A Boto3 API Gateway client.
"""
self.apig_client = apig_client
self.api_id = None
self.root_id = None
self.stage = None
def add_integration_method(
self,
resource_id,
rest_method,
service_endpoint_prefix,
service_action,
service_method,
role_arn,
mapping_template,
):
"""
Adds an integration method to a REST API. An integration method is a REST
resource, such as '/users', and an HTTP verb, such as GET. The integration
method is backed by an AWS service, such as Amazon DynamoDB.
:param resource_id: The ID of the REST resource.
:param rest_method: The HTTP verb used with the REST resource.
:param service_endpoint_prefix: The service endpoint that is integrated with
this method, such as 'dynamodb'.
:param service_action: The action that is called on the service, such as
'GetItem'.
:param service_method: The HTTP method of the service request, such as POST.
:param role_arn: The Amazon Resource Name (ARN) of a role that grants API
Gateway permission to use the specified action with the
service.
:param mapping_template: A mapping template that is used to translate REST
elements, such as query parameters, to the request
body format required by the service.
"""
service_uri = (
f"arn:aws:apigateway:{self.apig_client.meta.region_name}"
f":{service_endpoint_prefix}:action/{service_action}"
)
try:
self.apig_client.put_method(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
authorizationType="NONE",
)
self.apig_client.put_method_response(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
statusCode="200",
responseModels={"application/json": "Empty"},
)
logger.info("Created %s method for resource %s.", rest_method, resource_id)
except ClientError:
logger.exception(
"Couldn't create %s method for resource %s.", rest_method, resource_id
)
raise
try:
self.apig_client.put_integration(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
type="AWS",
integrationHttpMethod=service_method,
credentials=role_arn,
requestTemplates={"application/json": json.dumps(mapping_template)},
uri=service_uri,
passthroughBehavior="WHEN_NO_TEMPLATES",
)
self.apig_client.put_integration_response(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
statusCode="200",
responseTemplates={"application/json": ""},
)
logger.info(
"Created integration for resource %s to service URI %s.",
resource_id,
service_uri,
)
except ClientError:
logger.exception(
"Couldn't create integration for resource %s to service URI %s.",
resource_id,
service_uri,
)
raise
```
+ Per i dettagli sull'API, consulta [PutMethod AWS](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/PutMethod)*SDK for Python (Boto3) API Reference*.
### `PutMethodResponse`
Il seguente esempio di codice mostra come utilizzare. `PutMethodResponse`
**SDK per Python (Boto3)**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
```
class ApiGatewayToService:
"""
Encapsulates Amazon API Gateway functions that are used to create a REST API that
integrates with another AWS service.
"""
def __init__(self, apig_client):
"""
:param apig_client: A Boto3 API Gateway client.
"""
self.apig_client = apig_client
self.api_id = None
self.root_id = None
self.stage = None
def add_integration_method(
self,
resource_id,
rest_method,
service_endpoint_prefix,
service_action,
service_method,
role_arn,
mapping_template,
):
"""
Adds an integration method to a REST API. An integration method is a REST
resource, such as '/users', and an HTTP verb, such as GET. The integration
method is backed by an AWS service, such as Amazon DynamoDB.
:param resource_id: The ID of the REST resource.
:param rest_method: The HTTP verb used with the REST resource.
:param service_endpoint_prefix: The service endpoint that is integrated with
this method, such as 'dynamodb'.
:param service_action: The action that is called on the service, such as
'GetItem'.
:param service_method: The HTTP method of the service request, such as POST.
:param role_arn: The Amazon Resource Name (ARN) of a role that grants API
Gateway permission to use the specified action with the
service.
:param mapping_template: A mapping template that is used to translate REST
elements, such as query parameters, to the request
body format required by the service.
"""
service_uri = (
f"arn:aws:apigateway:{self.apig_client.meta.region_name}"
f":{service_endpoint_prefix}:action/{service_action}"
)
try:
self.apig_client.put_method(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
authorizationType="NONE",
)
self.apig_client.put_method_response(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
statusCode="200",
responseModels={"application/json": "Empty"},
)
logger.info("Created %s method for resource %s.", rest_method, resource_id)
except ClientError:
logger.exception(
"Couldn't create %s method for resource %s.", rest_method, resource_id
)
raise
try:
self.apig_client.put_integration(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
type="AWS",
integrationHttpMethod=service_method,
credentials=role_arn,
requestTemplates={"application/json": json.dumps(mapping_template)},
uri=service_uri,
passthroughBehavior="WHEN_NO_TEMPLATES",
)
self.apig_client.put_integration_response(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
statusCode="200",
responseTemplates={"application/json": ""},
)
logger.info(
"Created integration for resource %s to service URI %s.",
resource_id,
service_uri,
)
except ClientError:
logger.exception(
"Couldn't create integration for resource %s to service URI %s.",
resource_id,
service_uri,
)
raise
```
+ Per i dettagli sull'API, consulta [PutMethodResponse AWS](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/PutMethodResponse)*SDK for Python (Boto3) API Reference*.
## Scenari
### Creazione di una REST API per monitorare i dati COVID-19
Il seguente esempio di codice mostra come creare una REST API che simula un sistema per monitorare i casi quotidiani di COVID-19 negli Stati Uniti, utilizzando dati fittizi.
**SDK per Python (Boto3)**
Mostra come usare AWS Chalice con per AWS SDK per Python (Boto3) creare un'API REST serverless che utilizzi Amazon API Gateway e Amazon DynamoDB. AWS Lambda La REST API simula un sistema che monitora i casi giornalieri di COVID-19 negli Stati Uniti, utilizzando dati fittizi. Scopri come:
+ Usa AWS Chalice per definire i percorsi nelle funzioni Lambda che vengono chiamate per gestire le richieste REST che arrivano tramite API Gateway.
+ Utilizza le funzioni Lambda per recuperare e archiviare i dati in una tabella DynamoDB per soddisfare le richieste REST.
+ Definisci la struttura della tabella e le risorse dei ruoli di sicurezza in un AWS CloudFormation modello.
+ Usa AWS Chalice e CloudFormation per impacchettare e distribuire tutte le risorse necessarie.
+ Usa CloudFormation per ripulire tutte le risorse create.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, vedi l'esempio completo su [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/apigateway_covid-19_tracker).
**Servizi utilizzati in questo esempio**
+ Gateway API
+ CloudFormation
+ DynamoDB
+ Lambda
### Creazione di una REST API per la libreria di prestiti
L’esempio di codice seguente mostra come creare una libreria di prestiti in cui gli utenti possono prendere in prestito e restituire libri tramite una REST API supportata da un database Amazon Aurora.
**SDK per Python (Boto3)**
Mostra come utilizzare l' AWS SDK per Python (Boto3) API Amazon Relational Database Service (Amazon RDS) e AWS Chalice per creare un'API REST supportata da un database Amazon Aurora. Il servizio Web è completamente serverless e rappresenta una semplice libreria di prestiti in cui gli utenti possono prendere in prestito e restituire libri. Scopri come:
+ Creare e gestire un cluster di database Aurora serverless.
+ Utilizzalo per gestire le credenziali Gestione dei segreti AWS del database.
+ Implementare un livello di archiviazione di dati che utilizza Amazon RDS per spostare i dati dentro e fuori dal database.
+ Usa AWS Chalice per distribuire un'API REST serverless su Amazon API Gateway e. AWS Lambda
+ Utilizza il pacchetto Richieste per inviare le richieste al servizio Web.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, consulta l'esempio completo su. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/aurora_rest_lending_library)
**Servizi utilizzati in questo esempio**
+ Gateway API
+ Aurora
+ Lambda
+ Secrets Manager
### Creazione di un’applicazione di chat websocket
L’esempio di codice seguente mostra come creare un’applicazione chat servita da un’API websocket creata su Gateway Amazon API.
**SDK per Python (Boto3)**
Mostra come utilizzarlo AWS SDK per Python (Boto3) con Amazon API Gateway V2 per creare un'API websocket che si integri con Amazon AWS Lambda DynamoDB.
+ Crea un’API WebSocket servita da Gateway API.
+ Definisci un gestore Lambda che memorizzi le connessioni in DynamoDB e invii messaggi ad altri partecipanti alla chat.
+ Connettiti all’applicazione di chat websocket e invia messaggi con il pacchetto Websockets.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, consulta l'esempio completo su. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/apigateway_websocket_chat)
**Servizi utilizzati in questo esempio**
+ Gateway API
+ DynamoDB
+ Lambda
### Creare e distribuire una REST API
L’esempio di codice seguente mostra come:
+ Creare una REST API servita da Gateway API.
+ Aggiungere risorse alla REST API per rappresentare un profilo utente.
+ Aggiungere metodi di integrazione in modo che la REST API utilizzi una tabella DynamoDB per archiviare i dati del profilo utente.
+ Inviare richieste HTTP alla REST API per aggiungere e recuperare i profili utente.
**SDK per Python (Boto3)**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
Crea una classe per il wrapping delle operazioni di Gateway API.
```
import argparse
import json
import logging
from pprint import pprint
import boto3
from botocore.exceptions import ClientError
import requests
logger = logging.getLogger(__name__)
class ApiGatewayToService:
"""
Encapsulates Amazon API Gateway functions that are used to create a REST API that
integrates with another AWS service.
"""
def __init__(self, apig_client):
"""
:param apig_client: A Boto3 API Gateway client.
"""
self.apig_client = apig_client
self.api_id = None
self.root_id = None
self.stage = None
def create_rest_api(self, api_name):
"""
Creates a REST API on API Gateway. The default API has only a root resource
and no HTTP methods.
:param api_name: The name of the API. This descriptive name is not used in
the API path.
:return: The ID of the newly created API.
"""
try:
result = self.apig_client.create_rest_api(name=api_name)
self.api_id = result["id"]
logger.info("Created REST API %s with ID %s.", api_name, self.api_id)
except ClientError:
logger.exception("Couldn't create REST API %s.", api_name)
raise
try:
result = self.apig_client.get_resources(restApiId=self.api_id)
self.root_id = next(
item for item in result["items"] if item["path"] == "/"
)["id"]
except ClientError:
logger.exception("Couldn't get resources for API %s.", self.api_id)
raise
except StopIteration as err:
logger.exception("No root resource found in API %s.", self.api_id)
raise ValueError from err
return self.api_id
def add_rest_resource(self, parent_id, resource_path):
"""
Adds a resource to a REST API.
:param parent_id: The ID of the parent resource.
:param resource_path: The path of the new resource, relative to the parent.
:return: The ID of the new resource.
"""
try:
result = self.apig_client.create_resource(
restApiId=self.api_id, parentId=parent_id, pathPart=resource_path
)
resource_id = result["id"]
logger.info("Created resource %s.", resource_path)
except ClientError:
logger.exception("Couldn't create resource %s.", resource_path)
raise
else:
return resource_id
def add_integration_method(
self,
resource_id,
rest_method,
service_endpoint_prefix,
service_action,
service_method,
role_arn,
mapping_template,
):
"""
Adds an integration method to a REST API. An integration method is a REST
resource, such as '/users', and an HTTP verb, such as GET. The integration
method is backed by an AWS service, such as Amazon DynamoDB.
:param resource_id: The ID of the REST resource.
:param rest_method: The HTTP verb used with the REST resource.
:param service_endpoint_prefix: The service endpoint that is integrated with
this method, such as 'dynamodb'.
:param service_action: The action that is called on the service, such as
'GetItem'.
:param service_method: The HTTP method of the service request, such as POST.
:param role_arn: The Amazon Resource Name (ARN) of a role that grants API
Gateway permission to use the specified action with the
service.
:param mapping_template: A mapping template that is used to translate REST
elements, such as query parameters, to the request
body format required by the service.
"""
service_uri = (
f"arn:aws:apigateway:{self.apig_client.meta.region_name}"
f":{service_endpoint_prefix}:action/{service_action}"
)
try:
self.apig_client.put_method(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
authorizationType="NONE",
)
self.apig_client.put_method_response(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
statusCode="200",
responseModels={"application/json": "Empty"},
)
logger.info("Created %s method for resource %s.", rest_method, resource_id)
except ClientError:
logger.exception(
"Couldn't create %s method for resource %s.", rest_method, resource_id
)
raise
try:
self.apig_client.put_integration(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
type="AWS",
integrationHttpMethod=service_method,
credentials=role_arn,
requestTemplates={"application/json": json.dumps(mapping_template)},
uri=service_uri,
passthroughBehavior="WHEN_NO_TEMPLATES",
)
self.apig_client.put_integration_response(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
statusCode="200",
responseTemplates={"application/json": ""},
)
logger.info(
"Created integration for resource %s to service URI %s.",
resource_id,
service_uri,
)
except ClientError:
logger.exception(
"Couldn't create integration for resource %s to service URI %s.",
resource_id,
service_uri,
)
raise
def deploy_api(self, stage_name):
"""
Deploys a REST API. After a REST API is deployed, it can be called from any
REST client, such as the Python Requests package or Postman.
:param stage_name: The stage of the API to deploy, such as 'test'.
:return: The base URL of the deployed REST API.
"""
try:
self.apig_client.create_deployment(
restApiId=self.api_id, stageName=stage_name
)
self.stage = stage_name
logger.info("Deployed stage %s.", stage_name)
except ClientError:
logger.exception("Couldn't deploy stage %s.", stage_name)
raise
else:
return self.api_url()
def api_url(self, resource=None):
"""
Builds the REST API URL from its parts.
:param resource: The resource path to append to the base URL.
:return: The REST URL to the specified resource.
"""
url = (
f"https://{self.api_id}.execute-api.{self.apig_client.meta.region_name}"
f".amazonaws.com/{self.stage}"
)
if resource is not None:
url = f"{url}/{resource}"
return url
```
Distribuire una REST API e chiamarla con il pacchetto Requests.
```
def usage_demo(table_name, role_name, rest_api_name):
"""
Demonstrates how to used API Gateway to create and deploy a REST API, and how
to use the Requests package to call it.
:param table_name: The name of the demo DynamoDB table.
:param role_name: The name of the demo role that grants API Gateway permission to
call DynamoDB.
:param rest_api_name: The name of the demo REST API created by the demo.
"""
gateway = ApiGatewayToService(boto3.client("apigateway"))
role = boto3.resource("iam").Role(role_name)
print("Creating REST API in API Gateway.")
gateway.create_rest_api(rest_api_name)
print("Adding resources to the REST API.")
profiles_id = gateway.add_rest_resource(gateway.root_id, "profiles")
username_id = gateway.add_rest_resource(profiles_id, "{username}")
# The DynamoDB service requires that all integration requests use POST.
print("Adding integration methods to read and write profiles in Amazon DynamoDB.")
gateway.add_integration_method(
profiles_id,
"GET",
"dynamodb",
"Scan",
"POST",
role.arn,
{"TableName": table_name},
)
gateway.add_integration_method(
profiles_id,
"POST",
"dynamodb",
"PutItem",
"POST",
role.arn,
{
"TableName": table_name,
"Item": {
"username": {"S": "$input.path('$.username')"},
"name": {"S": "$input.path('$.name')"},
"title": {"S": "$input.path('$.title')"},
},
},
)
gateway.add_integration_method(
username_id,
"GET",
"dynamodb",
"GetItem",
"POST",
role.arn,
{
"TableName": table_name,
"Key": {"username": {"S": "$method.request.path.username"}},
},
)
stage = "test"
print(f"Deploying the {stage} stage.")
gateway.deploy_api(stage)
profiles_url = gateway.api_url("profiles")
print(
f"Using the Requests package to post some people to the profiles REST API at "
f"{profiles_url}."
)
requests.post(
profiles_url,
json={"username": "will", "name": "William Shakespeare", "title": "playwright"},
)
requests.post(
profiles_url,
json={
"username": "ludwig",
"name": "Ludwig van Beethoven",
"title": "composer",
},
)
requests.post(
profiles_url,
json={"username": "jane", "name": "Jane Austen", "title": "author"},
)
print("Getting the list of profiles from the REST API.")
profiles = requests.get(profiles_url).json()
pprint(profiles)
print(f"Getting just the profile for username 'jane' (URL: {profiles_url}/jane).")
jane = requests.get(f"{profiles_url}/jane").json()
pprint(jane)
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per Python (Boto3)*.
+ [CreateDeployment](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/CreateDeployment)
+ [CreateResource](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/CreateResource)
+ [CreateRestApi](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/CreateRestApi)
+ [DeleteRestApi](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/DeleteRestApi)
+ [GetResources](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/GetResources)
+ [GetRestApis](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/GetRestApis)
+ [PutIntegration](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/PutIntegration)
+ [PutIntegrationResponse](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/PutIntegrationResponse)
+ [PutMethod](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/PutMethod)
+ [PutMethodResponse](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/PutMethodResponse)
### Utilizzo di Gateway API per invocare una funzione Lambda
Il seguente esempio di codice mostra come creare una AWS Lambda funzione richiamata da Amazon API Gateway.
**SDK per Python (Boto3)**
L’esempio mostra come creare e utilizzare una REST API di Gateway Amazon API destinata a una funzione AWS Lambda . Il gestore Lambda dimostra come definire route in base ai metodi HTTP, come ottenere dati dalla stringa, dall’intestazione e dal corpo della query e come restituire una risposta JSON.
+ Distribuire una funzione Lambda.
+ Creare una REST API di Gateway API.
+ Creare una risorsa REST destinata alla funzione Lambda.
+ Concedere l’autorizzazione affinché Gateway API invochi la funzione Lambda.
+ Utilizza il pacchetto Richieste per inviare le richieste alla REST API.
+ Eliminare tutte le risorse create durante la demo.
Questo esempio è visualizzato al meglio su. GitHub Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, vedi l'esempio completo su [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/lambda#readme).
**Servizi utilizzati in questo esempio**
+ Gateway API
+ DynamoDB
+ Lambda
+ Amazon SNS