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 di codice SDK for PHP
Gli esempi di codice riportati in questo argomento mostrano come utilizzare AWS SDK per PHP with AWS.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
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.
Alcuni servizi contengono ulteriori categorie di esempi che mostrano come sfruttare le librerie o le funzioni specifiche del servizio.
**Topics**
+ [Gateway API](php_api-gateway_code_examples.md)
+ [Aurora](php_aurora_code_examples.md)
+ [Auto Scaling](php_auto-scaling_code_examples.md)
+ [Amazon Bedrock](php_bedrock_code_examples.md)
+ [API Runtime per Amazon Bedrock](php_bedrock-runtime_code_examples.md)
+ [Amazon DocumentDB](php_docdb_code_examples.md)
+ [DynamoDB](php_dynamodb_code_examples.md)
+ [Amazon EC2](php_ec2_code_examples.md)
+ [AWS Glue](php_glue_code_examples.md)
+ [IAM](php_iam_code_examples.md)
+ [Kinesis](php_kinesis_code_examples.md)
+ [AWS KMS](php_kms_code_examples.md)
+ [Lambda](php_lambda_code_examples.md)
+ [MSK Amazon](php_kafka_code_examples.md)
+ [Amazon RDS](php_rds_code_examples.md)
+ [Servizi di dati di Amazon RDS](php_rds-data_code_examples.md)
+ [Amazon Rekognition](php_rekognition_code_examples.md)
+ [Simple Storage Service (Amazon S3)](php_s3_code_examples.md)
+ [Bucket di directory S3](php_s3-directory-buckets_code_examples.md)
+ [Amazon SES](php_ses_code_examples.md)
+ [Amazon SNS](php_sns_code_examples.md)
+ [Amazon SQS](php_sqs_code_examples.md)
# Esempi per Gateway API con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP 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
### `GetBasePathMapping`
Il seguente esempio di codice mostra come utilizzare`GetBasePathMapping`.
**SDK per PHP**
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/php/example_code/apigateway#code-examples).
```
require 'vendor/autoload.php';
use Aws\ApiGateway\ApiGatewayClient;
use Aws\Exception\AwsException;
/* ////////////////////////////////////////////////////////////////////////////
* Purpose: Gets the base path mapping for a custom domain name in
* Amazon API Gateway.
*
* Prerequisites: A custom domain name in API Gateway. For more information,
* see "Custom Domain Names" in the Amazon API Gateway Developer Guide.
*
* Inputs:
* - $apiGatewayClient: An initialized AWS SDK for PHP API client for
* API Gateway.
* - $basePath: The base path name that callers must provide as part of the
* URL after the domain name.
* - $domainName: The custom domain name for the base path mapping.
*
* Returns: The base path mapping, if available; otherwise, the error message.
* ///////////////////////////////////////////////////////////////////////// */
function getBasePathMapping($apiGatewayClient, $basePath, $domainName)
{
try {
$result = $apiGatewayClient->getBasePathMapping([
'basePath' => $basePath,
'domainName' => $domainName,
]);
return 'The base path mapping\'s effective URI is: ' .
$result['@metadata']['effectiveUri'];
} catch (AwsException $e) {
return 'Error: ' . $e['message'];
}
}
function getsTheBasePathMapping()
{
$apiGatewayClient = new ApiGatewayClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2015-07-09'
]);
echo getBasePathMapping($apiGatewayClient, '(none)', 'example.com');
}
// Uncomment the following line to run this code in an AWS account.
// getsTheBasePathMapping();
```
+ Per i dettagli sull'API, [GetBasePathMapping](https://docs.aws.amazon.com/goto/SdkForPHPV3/apigateway-2015-07-09/GetBasePathMapping)consulta *AWS SDK per PHP API Reference*.
### `ListBasePathMappings`
Il seguente esempio di codice mostra come utilizzare`ListBasePathMappings`.
**SDK per PHP**
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/php/example_code/apigateway#code-examples).
```
require 'vendor/autoload.php';
use Aws\ApiGateway\ApiGatewayClient;
use Aws\Exception\AwsException;
/* ////////////////////////////////////////////////////////////////////////////
* Purpose: Lists the base path mapping for a custom domain name in
* Amazon API Gateway.
*
* Prerequisites: A custom domain name in API Gateway. For more information,
* see "Custom Domain Names" in the Amazon API Gateway Developer Guide.
*
* Inputs:
* - $apiGatewayClient: An initialized AWS SDK for PHP API client for
* API Gateway.
* - $domainName: The custom domain name for the base path mappings.
*
* Returns: Information about the base path mappings, if available;
* otherwise, the error message.
* ///////////////////////////////////////////////////////////////////////// */
function listBasePathMappings($apiGatewayClient, $domainName)
{
try {
$result = $apiGatewayClient->getBasePathMappings([
'domainName' => $domainName
]);
return 'The base path mapping(s) effective URI is: ' .
$result['@metadata']['effectiveUri'];
} catch (AwsException $e) {
return 'Error: ' . $e['message'];
}
}
function listTheBasePathMappings()
{
$apiGatewayClient = new ApiGatewayClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2015-07-09'
]);
echo listBasePathMappings($apiGatewayClient, 'example.com');
}
// Uncomment the following line to run this code in an AWS account.
// listTheBasePathMappings();
```
+ Per i dettagli sull'API, [ListBasePathMappings](https://docs.aws.amazon.com/goto/SdkForPHPV3/apigateway-2015-07-09/ListBasePathMappings)consulta *AWS SDK per PHP API Reference*.
### `UpdateBasePathMapping`
Il seguente esempio di codice mostra come utilizzare`UpdateBasePathMapping`.
**SDK per PHP**
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/php/example_code/apigateway#code-examples).
```
require 'vendor/autoload.php';
use Aws\ApiGateway\ApiGatewayClient;
use Aws\Exception\AwsException;
/* ////////////////////////////////////////////////////////////////////////////
*
* Purpose: Updates the base path mapping for a custom domain name
* in Amazon API Gateway.
*
* Inputs:
* - $apiGatewayClient: An initialized AWS SDK for PHP API client for
* API Gateway.
* - $basePath: The base path name that callers must provide as part of the
* URL after the domain name.
* - $domainName: The custom domain name for the base path mapping.
* - $patchOperations: The base path update operations to apply.
*
* Returns: Information about the updated base path mapping, if available;
* otherwise, the error message.
* ///////////////////////////////////////////////////////////////////////// */
function updateBasePathMapping(
$apiGatewayClient,
$basePath,
$domainName,
$patchOperations
) {
try {
$result = $apiGatewayClient->updateBasePathMapping([
'basePath' => $basePath,
'domainName' => $domainName,
'patchOperations' => $patchOperations
]);
return 'The updated base path\'s URI is: ' .
$result['@metadata']['effectiveUri'];
} catch (AwsException $e) {
return 'Error: ' . $e['message'];
}
}
function updateTheBasePathMapping()
{
$patchOperations = array([
'op' => 'replace',
'path' => '/stage',
'value' => 'stage2'
]);
$apiGatewayClient = new ApiGatewayClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2015-07-09'
]);
echo updateBasePathMapping(
$apiGatewayClient,
'(none)',
'example.com',
$patchOperations
);
}
// Uncomment the following line to run this code in an AWS account.
// updateTheBasePathMapping();
```
+ Per i dettagli sull'API, [UpdateBasePathMapping](https://docs.aws.amazon.com/goto/SdkForPHPV3/apigateway-2015-07-09/UpdateBasePathMapping)consulta *AWS SDK per PHP API Reference*.
## Scenari
### Creazione di un’applicazione serverless per gestire foto
L’esempio di codice seguente mostra come creare un’applicazione serverless che consente agli utenti di gestire le foto mediante etichette.
**SDK per PHP**
Mostra come sviluppare un’applicazione per la gestione delle risorse fotografiche che rileva le etichette nelle immagini utilizzando Amazon Rekognition e le archivia per recuperarle in seguito.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Per approfondire l’origine di questo esempio, consulta il post su [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servizi utilizzati in questo esempio**
+ Gateway API
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Simple Storage Service (Amazon S3)
+ Amazon SNS
# Esempi per Aurora con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP con Aurora.
*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, dove è possibile trovare le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Scenari](#scenarios)
## Scenari
### Creazione di un tracciatore di elementi di lavoro di Aurora Serverless
L’esempio di codice seguente mostra come creare un’applicazione web che traccia gli elementi di lavoro in database Amazon Aurora serverless e utilizza Amazon Simple Email Service (Amazon SES) per inviare report.
**SDK per PHP**
Mostra come utilizzare per AWS SDK per PHP creare un'applicazione Web che tenga traccia degli elementi di lavoro in un database Amazon RDS e invii report tramite e-mail utilizzando Amazon Simple Email Service (Amazon SES). Questo esempio utilizza un front-end creato con React.js per interagire con un backend RESTful PHP.
+ Integra un'applicazione web React.js con AWS i servizi.
+ Elenca, aggiungi, aggiorna ed elimina gli elementi in una tabella Amazon RDS.
+ Invia un report per e-mail degli articoli di lavoro filtrati tramite Amazon SES.
+ Distribuisci e gestisci risorse di esempio con lo AWS CloudFormation script incluso.
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/php/cross_service/aurora_item_tracker).
**Servizi utilizzati in questo esempio**
+ Aurora
+ Amazon RDS
+ Servizi di dati di Amazon RDS
+ Amazon SES
# Esempi per Auto Scaling con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP con Auto Scaling.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
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.
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**
+ [Nozioni di base](#get_started)
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
## Nozioni di base
### Hello Auto Scaling
Il seguente esempio di codice mostra come iniziare a usare Auto Scaling.
**SDK per PHP**
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/php/example_code/auto-scaling#code-examples).
```
public function helloService()
{
$autoScalingClient = new AutoScalingClient([
'region' => 'us-west-2',
'version' => 'latest',
'profile' => 'default',
]);
$groups = $autoScalingClient->describeAutoScalingGroups([]);
var_dump($groups);
}
```
+ Per i dettagli sull'API, [DescribeAutoScalingGroups](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeAutoScalingGroups)consulta *AWS SDK per PHP API Reference*.
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come:
+ Crea un gruppo Amazon EC2 Auto Scaling con un modello di lancio e zone di disponibilità e ottieni informazioni sulle istanze in esecuzione.
+ Abilita la raccolta di CloudWatch metriche Amazon.
+ Aggiornare la capacità desiderata del gruppo e attendere l’avvio di un’istanza.
+ Terminare un’istanza nel gruppo.
+ Elencare le attività di dimensionamento che si verificano in risposta alle richieste degli utenti e alle modifiche della capacità.
+ Ottieni statistiche per le CloudWatch metriche, quindi ripulisci le risorse.
**SDK per PHP**
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/php/example_code/auto-scaling#code-examples).
```
namespace AutoScaling;
use Aws\AutoScaling\AutoScalingClient;
use Aws\CloudWatch\CloudWatchClient;
use Aws\Ec2\Ec2Client;
use AwsUtilities\AWSServiceClass;
use AwsUtilities\RunnableExample;
class GettingStartedWithAutoScaling implements RunnableExample
{
protected Ec2Client $ec2Client;
protected AutoScalingClient $autoScalingClient;
protected AutoScalingService $autoScalingService;
protected CloudWatchClient $cloudWatchClient;
protected string $templateName;
protected string $autoScalingGroupName;
protected array $role;
public function runExample()
{
echo("\n");
echo("--------------------------------------\n");
print("Welcome to the Amazon EC2 Auto Scaling getting started demo using PHP!\n");
echo("--------------------------------------\n");
$clientArgs = [
'region' => 'us-west-2',
'version' => 'latest',
'profile' => 'default',
];
$uniqid = uniqid();
$this->autoScalingClient = new AutoScalingClient($clientArgs);
$this->autoScalingService = new AutoScalingService($this->autoScalingClient);
$this->cloudWatchClient = new CloudWatchClient($clientArgs);
AWSServiceClass::$waitTime = 5;
AWSServiceClass::$maxWaitAttempts = 20;
/**
* Step 0: Create an EC2 launch template that you'll use to create an Auto Scaling group.
*/
$this->ec2Client = new EC2Client($clientArgs);
$this->templateName = "example_launch_template_$uniqid";
$instanceType = "t1.micro";
$amiId = "ami-0ca285d4c2cda3300";
$launchTemplate = $this->ec2Client->createLaunchTemplate(
[
'LaunchTemplateName' => $this->templateName,
'LaunchTemplateData' => [
'InstanceType' => $instanceType,
'ImageId' => $amiId,
]
]
);
/**
* Step 1: CreateAutoScalingGroup: pass it the launch template you created in step 0.
*/
$availabilityZones[] = $this->ec2Client->describeAvailabilityZones([])['AvailabilityZones'][1]['ZoneName'];
$this->autoScalingGroupName = "demoAutoScalingGroupName_$uniqid";
$minSize = 1;
$maxSize = 1;
$launchTemplateId = $launchTemplate['LaunchTemplate']['LaunchTemplateId'];
$this->autoScalingService->createAutoScalingGroup(
$this->autoScalingGroupName,
$availabilityZones,
$minSize,
$maxSize,
$launchTemplateId
);
$this->autoScalingService->waitUntilGroupInService([$this->autoScalingGroupName]);
$autoScalingGroup = $this->autoScalingService->describeAutoScalingGroups([$this->autoScalingGroupName]);
/**
* Step 2: DescribeAutoScalingInstances: show that one instance has launched.
*/
$instanceIds = [$autoScalingGroup['AutoScalingGroups'][0]['Instances'][0]['InstanceId']];
$instances = $this->autoScalingService->describeAutoScalingInstances($instanceIds);
echo "The Auto Scaling group {$this->autoScalingGroupName} was created successfully.\n";
echo count($instances['AutoScalingInstances']) . " instances were created for the group.\n";
echo $autoScalingGroup['AutoScalingGroups'][0]['MaxSize'] . " is the max number of instances for the group.\n";
/**
* Step 3: EnableMetricsCollection: enable all metrics or a subset.
*/
$this->autoScalingService->enableMetricsCollection($this->autoScalingGroupName, "1Minute");
/**
* Step 4: UpdateAutoScalingGroup: update max size to 3.
*/
echo "Updating the max number of instances to 3.\n";
$this->autoScalingService->updateAutoScalingGroup($this->autoScalingGroupName, ['MaxSize' => 3]);
/**
* Step 5: DescribeAutoScalingGroups: show the current state of the group.
*/
$autoScalingGroup = $this->autoScalingService->describeAutoScalingGroups([$this->autoScalingGroupName]);
echo $autoScalingGroup['AutoScalingGroups'][0]['MaxSize'];
echo " is the updated max number of instances for the group.\n";
$limits = $this->autoScalingService->describeAccountLimits();
echo "Here are your account limits:\n";
echo "MaxNumberOfAutoScalingGroups: {$limits['MaxNumberOfAutoScalingGroups']}\n";
echo "MaxNumberOfLaunchConfigurations: {$limits['MaxNumberOfLaunchConfigurations']}\n";
echo "NumberOfAutoScalingGroups: {$limits['NumberOfAutoScalingGroups']}\n";
echo "NumberOfLaunchConfigurations: {$limits['NumberOfLaunchConfigurations']}\n";
/**
* Step 6: SetDesiredCapacity: set desired capacity to 2.
*/
$this->autoScalingService->setDesiredCapacity($this->autoScalingGroupName, 2);
sleep(10); // Wait for the group to start processing the request.
$this->autoScalingService->waitUntilGroupInService([$this->autoScalingGroupName]);
/**
* Step 7: DescribeAutoScalingInstances: show that two instances are launched.
*/
$autoScalingGroups = $this->autoScalingService->describeAutoScalingGroups([$this->autoScalingGroupName]);
foreach ($autoScalingGroups['AutoScalingGroups'] as $autoScalingGroup) {
echo "There is a group named: {$autoScalingGroup['AutoScalingGroupName']}";
echo "with an ARN of {$autoScalingGroup['AutoScalingGroupARN']}.\n";
foreach ($autoScalingGroup['Instances'] as $instance) {
echo "{$autoScalingGroup['AutoScalingGroupName']} has an instance with id of: ";
echo "{$instance['InstanceId']} and a lifecycle state of: {$instance['LifecycleState']}.\n";
}
}
/**
* Step 8: TerminateInstanceInAutoScalingGroup: terminate one of the instances in the group.
*/
$this->autoScalingService->terminateInstanceInAutoScalingGroup($instance['InstanceId'], false);
do {
sleep(10);
$instances = $this->autoScalingService->describeAutoScalingInstances([$instance['InstanceId']]);
} while (count($instances['AutoScalingInstances']) > 0);
do {
sleep(10);
$autoScalingGroups = $this->autoScalingService->describeAutoScalingGroups([$this->autoScalingGroupName]);
$instances = $autoScalingGroups['AutoScalingGroups'][0]['Instances'];
} while (count($instances) < 2);
$this->autoScalingService->waitUntilGroupInService([$this->autoScalingGroupName]);
foreach ($autoScalingGroups['AutoScalingGroups'] as $autoScalingGroup) {
echo "There is a group named: {$autoScalingGroup['AutoScalingGroupName']}";
echo "with an ARN of {$autoScalingGroup['AutoScalingGroupARN']}.\n";
foreach ($autoScalingGroup['Instances'] as $instance) {
echo "{$autoScalingGroup['AutoScalingGroupName']} has an instance with id of: ";
echo "{$instance['InstanceId']} and a lifecycle state of: {$instance['LifecycleState']}.\n";
}
}
/**
* Step 9: DescribeScalingActivities: list the scaling activities that have occurred for the group so far.
*/
$activities = $this->autoScalingService->describeScalingActivities($autoScalingGroup['AutoScalingGroupName']);
echo "We found " . count($activities['Activities']) . " activities.\n";
foreach ($activities['Activities'] as $activity) {
echo "{$activity['ActivityId']} - {$activity['StartTime']} - {$activity['Description']}\n";
}
/**
* Step 10: Use the Amazon CloudWatch API to get and show some metrics collected for the group.
*/
$metricsNamespace = 'AWS/AutoScaling';
$metricsDimensions = [
[
'Name' => 'AutoScalingGroupName',
'Value' => $autoScalingGroup['AutoScalingGroupName'],
],
];
$metrics = $this->cloudWatchClient->listMetrics(
[
'Dimensions' => $metricsDimensions,
'Namespace' => $metricsNamespace,
]
);
foreach ($metrics['Metrics'] as $metric) {
$timespan = 5;
if ($metric['MetricName'] != 'GroupTotalCapacity' && $metric['MetricName'] != 'GroupMaxSize') {
continue;
}
echo "Over the last $timespan minutes, {$metric['MetricName']} recorded:\n";
$stats = $this->cloudWatchClient->getMetricStatistics(
[
'Dimensions' => $metricsDimensions,
'EndTime' => time(),
'StartTime' => time() - (5 * 60),
'MetricName' => $metric['MetricName'],
'Namespace' => $metricsNamespace,
'Period' => 60,
'Statistics' => ['Sum'],
]
);
foreach ($stats['Datapoints'] as $stat) {
echo "{$stat['Timestamp']}: {$stat['Sum']}\n";
}
}
return $instances;
}
public function cleanUp()
{
/**
* Step 11: DisableMetricsCollection: disable all metrics.
*/
$this->autoScalingService->disableMetricsCollection($this->autoScalingGroupName);
/**
* Step 12: DeleteAutoScalingGroup: to delete the group you must stop all instances.
* - UpdateAutoScalingGroup with MinSize=0
* - TerminateInstanceInAutoScalingGroup for each instance,
* specify ShouldDecrementDesiredCapacity=True. Wait for instances to stop.
* - Now you can delete the group.
*/
$this->autoScalingService->updateAutoScalingGroup($this->autoScalingGroupName, ['MinSize' => 0]);
$this->autoScalingService->terminateAllInstancesInAutoScalingGroup($this->autoScalingGroupName);
$this->autoScalingService->waitUntilGroupInService([$this->autoScalingGroupName]);
$this->autoScalingService->deleteAutoScalingGroup($this->autoScalingGroupName);
/**
* Step 13: Delete launch template.
*/
$this->ec2Client->deleteLaunchTemplate(
[
'LaunchTemplateName' => $this->templateName,
]
);
}
public function helloService()
{
$autoScalingClient = new AutoScalingClient([
'region' => 'us-west-2',
'version' => 'latest',
'profile' => 'default',
]);
$groups = $autoScalingClient->describeAutoScalingGroups([]);
var_dump($groups);
}
}
```
+ Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per PHP *.
+ [CreateAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/CreateAutoScalingGroup)
+ [DeleteAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DeleteAutoScalingGroup)
+ [DescribeAutoScalingGroups](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeAutoScalingGroups)
+ [DescribeAutoScalingInstances](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeAutoScalingInstances)
+ [DescribeScalingActivities](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeScalingActivities)
+ [DisableMetricsCollection](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DisableMetricsCollection)
+ [EnableMetricsCollection](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/EnableMetricsCollection)
+ [SetDesiredCapacity](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/SetDesiredCapacity)
+ [TerminateInstanceInAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/TerminateInstanceInAutoScalingGroup)
+ [UpdateAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/UpdateAutoScalingGroup)
## Azioni
### `CreateAutoScalingGroup`
Il seguente esempio di codice mostra come usare`CreateAutoScalingGroup`.
**SDK per PHP**
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/php/example_code/auto-scaling#code-examples).
```
public function createAutoScalingGroup(
$autoScalingGroupName,
$availabilityZones,
$minSize,
$maxSize,
$launchTemplateId
) {
return $this->autoScalingClient->createAutoScalingGroup([
'AutoScalingGroupName' => $autoScalingGroupName,
'AvailabilityZones' => $availabilityZones,
'MinSize' => $minSize,
'MaxSize' => $maxSize,
'LaunchTemplate' => [
'LaunchTemplateId' => $launchTemplateId,
],
]);
}
```
+ Per i dettagli sull'API, [CreateAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/CreateAutoScalingGroup)consulta *AWS SDK per PHP API Reference*.
### `DeleteAutoScalingGroup`
Il seguente esempio di codice mostra come utilizzare`DeleteAutoScalingGroup`.
**SDK per PHP**
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/php/example_code/auto-scaling#code-examples).
```
public function deleteAutoScalingGroup($autoScalingGroupName)
{
return $this->autoScalingClient->deleteAutoScalingGroup([
'AutoScalingGroupName' => $autoScalingGroupName,
'ForceDelete' => true,
]);
}
```
+ Per i dettagli sull'API, [DeleteAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DeleteAutoScalingGroup)consulta *AWS SDK per PHP API Reference*.
### `DescribeAutoScalingGroups`
Il seguente esempio di codice mostra come utilizzare`DescribeAutoScalingGroups`.
**SDK per PHP**
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/php/example_code/auto-scaling#code-examples).
```
public function describeAutoScalingGroups($autoScalingGroupNames)
{
return $this->autoScalingClient->describeAutoScalingGroups([
'AutoScalingGroupNames' => $autoScalingGroupNames
]);
}
```
+ Per i dettagli sull'API, [DescribeAutoScalingGroups](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeAutoScalingGroups)consulta *AWS SDK per PHP API Reference*.
### `DescribeAutoScalingInstances`
Il seguente esempio di codice mostra come utilizzare`DescribeAutoScalingInstances`.
**SDK per PHP**
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/php/example_code/auto-scaling#code-examples).
```
public function describeAutoScalingInstances($instanceIds)
{
return $this->autoScalingClient->describeAutoScalingInstances([
'InstanceIds' => $instanceIds
]);
}
```
+ Per i dettagli sull'API, [DescribeAutoScalingInstances](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeAutoScalingInstances)consulta *AWS SDK per PHP API Reference*.
### `DescribeScalingActivities`
Il seguente esempio di codice mostra come utilizzare`DescribeScalingActivities`.
**SDK per PHP**
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/php/example_code/auto-scaling#code-examples).
```
public function describeScalingActivities($autoScalingGroupName)
{
return $this->autoScalingClient->describeScalingActivities([
'AutoScalingGroupName' => $autoScalingGroupName,
]);
}
```
+ Per i dettagli sull'API, [DescribeScalingActivities](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeScalingActivities)consulta *AWS SDK per PHP API Reference*.
### `DisableMetricsCollection`
Il seguente esempio di codice mostra come utilizzare`DisableMetricsCollection`.
**SDK per PHP**
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/php/example_code/auto-scaling#code-examples).
```
public function disableMetricsCollection($autoScalingGroupName)
{
return $this->autoScalingClient->disableMetricsCollection([
'AutoScalingGroupName' => $autoScalingGroupName,
]);
}
```
+ Per i dettagli sull'API, [DisableMetricsCollection](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DisableMetricsCollection)consulta *AWS SDK per PHP API Reference*.
### `EnableMetricsCollection`
Il seguente esempio di codice mostra come utilizzare`EnableMetricsCollection`.
**SDK per PHP**
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/php/example_code/auto-scaling#code-examples).
```
public function enableMetricsCollection($autoScalingGroupName, $granularity)
{
return $this->autoScalingClient->enableMetricsCollection([
'AutoScalingGroupName' => $autoScalingGroupName,
'Granularity' => $granularity,
]);
}
```
+ Per i dettagli sull'API, [EnableMetricsCollection](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/EnableMetricsCollection)consulta *AWS SDK per PHP API Reference*.
### `SetDesiredCapacity`
Il seguente esempio di codice mostra come utilizzare`SetDesiredCapacity`.
**SDK per PHP**
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/php/example_code/auto-scaling#code-examples).
```
public function setDesiredCapacity($autoScalingGroupName, $desiredCapacity)
{
return $this->autoScalingClient->setDesiredCapacity([
'AutoScalingGroupName' => $autoScalingGroupName,
'DesiredCapacity' => $desiredCapacity,
]);
}
```
+ Per i dettagli sull'API, [SetDesiredCapacity](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/SetDesiredCapacity)consulta *AWS SDK per PHP API Reference*.
### `TerminateInstanceInAutoScalingGroup`
Il seguente esempio di codice mostra come utilizzare`TerminateInstanceInAutoScalingGroup`.
**SDK per PHP**
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/php/example_code/auto-scaling#code-examples).
```
public function terminateInstanceInAutoScalingGroup(
$instanceId,
$shouldDecrementDesiredCapacity = true,
$attempts = 0
) {
try {
return $this->autoScalingClient->terminateInstanceInAutoScalingGroup([
'InstanceId' => $instanceId,
'ShouldDecrementDesiredCapacity' => $shouldDecrementDesiredCapacity,
]);
} catch (AutoScalingException $exception) {
if ($exception->getAwsErrorCode() == "ScalingActivityInProgress" && $attempts < 5) {
error_log("Cannot terminate an instance while it is still pending. Waiting then trying again.");
sleep(5 * (1 + $attempts));
return $this->terminateInstanceInAutoScalingGroup(
$instanceId,
$shouldDecrementDesiredCapacity,
++$attempts
);
} else {
throw $exception;
}
}
}
```
+ Per i dettagli sull'API, [TerminateInstanceInAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/TerminateInstanceInAutoScalingGroup)consulta *AWS SDK per PHP API Reference*.
### `UpdateAutoScalingGroup`
Il seguente esempio di codice mostra come utilizzare`UpdateAutoScalingGroup`.
**SDK per PHP**
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/php/example_code/auto-scaling#code-examples).
```
public function updateAutoScalingGroup($autoScalingGroupName, $args)
{
if (array_key_exists('MaxSize', $args)) {
$maxSize = ['MaxSize' => $args['MaxSize']];
} else {
$maxSize = [];
}
if (array_key_exists('MinSize', $args)) {
$minSize = ['MinSize' => $args['MinSize']];
} else {
$minSize = [];
}
$parameters = ['AutoScalingGroupName' => $autoScalingGroupName];
$parameters = array_merge($parameters, $minSize, $maxSize);
return $this->autoScalingClient->updateAutoScalingGroup($parameters);
}
```
+ Per i dettagli sull'API, [UpdateAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/UpdateAutoScalingGroup)consulta *AWS SDK per PHP API Reference*.
# Esempi per Amazon Bedrock con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando Amazon Bedrock. AWS SDK per PHP
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.
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)
## Azioni
### `ListFoundationModels`
Il seguente esempio di codice mostra come usare`ListFoundationModels`.
**SDK per PHP**
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/php/example_code/bedrock#code-examples).
Elenca i modelli di fondazione di Amazon Bedrock disponibili.
```
public function listFoundationModels()
{
$bedrockClient = new BedrockClient([
'region' => 'us-west-2',
'profile' => 'default'
]);
$response = $bedrockClient->listFoundationModels();
return $response['modelSummaries'];
}
```
+ Per i dettagli sull'API, [ListFoundationModels](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-2023-04-20/ListFoundationModels)consulta *AWS SDK per PHP API Reference*.
# Esempi per l’API Runtime per Amazon Bedrock con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP with Amazon Bedrock Runtime.
*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, dove è possibile trovare le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Scenari](#scenarios)
+ [Amazon Nova](#amazon_nova)
+ [Generatore di immagini Amazon Titan](#amazon_titan_image_generator)
+ [Anthropic Claude](#anthropic_claude)
+ [Diffusione stabile](#stable_diffusion)
## Scenari
### Invocare più modelli di fondazione in Amazon Bedrock
Il seguente esempio di codice mostra come preparare e inviare un prompt a una varietà di modelli in grandi lingue (LLMs) su Amazon Bedrock
**SDK per PHP**
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/php/example_code/bedrock-runtime/#code-examples).
Richiama più elementi LLMs su Amazon Bedrock.
```
namespace BedrockRuntime;
class GettingStartedWithBedrockRuntime
{
protected BedrockRuntimeService $bedrockRuntimeService;
public function runExample()
{
echo "\n";
echo "---------------------------------------------------------------------\n";
echo "Welcome to the Amazon Bedrock Runtime getting started demo using PHP!\n";
echo "---------------------------------------------------------------------\n";
$bedrockRuntimeService = new BedrockRuntimeService();
$prompt = 'In one paragraph, who are you?';
echo "\nPrompt: " . $prompt;
echo "\n\nAnthropic Claude:\n";
echo $bedrockRuntimeService->invokeClaude($prompt);
echo "\n---------------------------------------------------------------------\n";
$image_prompt = 'stylized picture of a cute old steampunk robot';
echo "\nImage prompt: " . $image_prompt;
echo "\n\nStability.ai Stable Diffusion XL:\n";
$diffusionSeed = rand(0, 4294967295);
$style_preset = 'photographic';
$base64 = $bedrockRuntimeService->invokeStableDiffusion($image_prompt, $diffusionSeed, $style_preset);
$image_path = $this->saveImage($base64, 'stability.stable-diffusion-xl');
echo "The generated image has been saved to $image_path";
echo "\n\nAmazon Titan Image Generation:\n";
$titanSeed = rand(0, 2147483647);
$base64 = $bedrockRuntimeService->invokeTitanImage($image_prompt, $titanSeed);
$image_path = $this->saveImage($base64, 'amazon.titan-image-generator-v2');
echo "The generated image has been saved to $image_path";
}
private function saveImage($base64_image_data, $model_id): string
{
$output_dir = "output";
if (!file_exists($output_dir)) {
mkdir($output_dir);
}
$i = 1;
while (file_exists("$output_dir/$model_id" . '_' . "$i.png")) {
$i++;
}
$image_data = base64_decode($base64_image_data);
$file_path = "$output_dir/$model_id" . '_' . "$i.png";
$file = fopen($file_path, 'wb');
fwrite($file, $image_data);
fclose($file);
return $file_path;
}
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per PHP *.
+ [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)
+ [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)
## Amazon Nova
### Converse
L’esempio di codice seguente mostra come inviare un messaggio di testo ad Amazon Nova utilizzando l’API Converse di Bedrock.
**SDK per PHP**
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/php/example_code/bedrock-runtime#code-examples).
Invia un messaggio di testo ad Amazon Nova utilizzando l’API Converse di Bedrock.
```
// Use the Conversation API to send a text message to Amazon Nova.
use Aws\BedrockRuntime\BedrockRuntimeClient;
use Aws\Exception\AwsException;
use RuntimeException;
class Converse
{
public function converse(): string
{
// Create a Bedrock Runtime client in the AWS Region you want to use.
$client = new BedrockRuntimeClient([
'region' => 'us-east-1',
'profile' => 'default'
]);
// Set the model ID, e.g., Amazon Nova Lite.
$modelId = 'amazon.nova-lite-v1:0';
// Start a conversation with the user message.
$userMessage = "Describe the purpose of a 'hello world' program in one line.";
$conversation = [
[
"role" => "user",
"content" => [["text" => $userMessage]]
]
];
try {
// Send the message to the model, using a basic inference configuration.
$response = $client->converse([
'modelId' => $modelId,
'messages' => $conversation,
'inferenceConfig' => [
'maxTokens' => 512,
'temperature' => 0.5
]
]);
// Extract and return the response text.
$responseText = $response['output']['message']['content'][0]['text'];
return $responseText;
} catch (AwsException $e) {
echo "ERROR: Can't invoke {$modelId}. Reason: {$e->getAwsErrorMessage()}";
throw new RuntimeException("Failed to invoke model: " . $e->getAwsErrorMessage(), 0, $e);
}
}
}
$demo = new Converse();
echo $demo->converse();
```
+ Per informazioni dettagliate sull’API, consulta [Converse](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/Converse) nella *documentazione di riferimento dell’API AWS SDK per PHP *.
## Generatore di immagini Amazon Titan
### InvokeModel
L’esempio di codice seguente mostra come invocare Generatore di immagini Amazon Titan in Amazon Bedrock per generare un’immagine.
**SDK per PHP**
C'è dell'altro 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/php/example_code/bedrock-runtime#code-examples).
Crea un’immagine con Generatore di immagini Amazon Titan.
```
public function invokeTitanImage(string $prompt, int $seed)
{
// The different model providers have individual request and response formats.
// For the format, ranges, and default values for Titan Image models refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-titan-image.html
$base64_image_data = "";
try {
$modelId = 'amazon.titan-image-generator-v2:0';
$request = json_encode([
'taskType' => 'TEXT_IMAGE',
'textToImageParams' => [
'text' => $prompt
],
'imageGenerationConfig' => [
'numberOfImages' => 1,
'quality' => 'standard',
'cfgScale' => 8.0,
'height' => 512,
'width' => 512,
'seed' => $seed
]
]);
$result = $this->bedrockRuntimeClient->invokeModel([
'contentType' => 'application/json',
'body' => $request,
'modelId' => $modelId,
]);
$response_body = json_decode($result['body']);
$base64_image_data = $response_body->images[0];
} catch (Exception $e) {
echo "Error: ({$e->getCode()}) - {$e->getMessage()}\n";
}
return $base64_image_data;
}
```
+ Per i dettagli sull'API, [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)consulta *AWS SDK per PHP API Reference*.
## Anthropic Claude
### InvokeModel
L’esempio di codice seguente mostra come inviare un messaggio di testo a Anthropic Claude, utilizzando l’API Invoke Model.
**SDK per PHP**
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/php/example_code/bedrock-runtime#code-examples).
Invoca il modello di fondazione Anthropic Claude 2 per generare testo.
```
public function invokeClaude($prompt)
{
// The different model providers have individual request and response formats.
// For the format, ranges, and default values for Anthropic Claude, refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html
$completion = "";
try {
$modelId = 'anthropic.claude-3-haiku-20240307-v1:0';
// Claude requires you to enclose the prompt as follows:
$body = [
'anthropic_version' => 'bedrock-2023-05-31',
'max_tokens' => 512,
'temperature' => 0.5,
'messages' => [[
'role' => 'user',
'content' => $prompt
]]
];
$result = $this->bedrockRuntimeClient->invokeModel([
'contentType' => 'application/json',
'body' => json_encode($body),
'modelId' => $modelId,
]);
$response_body = json_decode($result['body']);
$completion = $response_body->content[0]->text;
} catch (Exception $e) {
echo "Error: ({$e->getCode()}) - {$e->getMessage()}\n";
}
return $completion;
}
```
+ Per i dettagli sull'API, [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)consulta *AWS SDK per PHP API Reference*.
## Diffusione stabile
### InvokeModel
L’esempio di codice seguente mostra come invocare il modello Stable Diffusion XL di Stability AI in Amazon Bedrock per generare un’immagine.
**SDK per PHP**
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/php/example_code/bedrock-runtime#code-examples).
Crea un’immagine con Stable Diffusion.
```
public function invokeStableDiffusion(string $prompt, int $seed, string $style_preset)
{
// The different model providers have individual request and response formats.
// For the format, ranges, and available style_presets of Stable Diffusion models refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-stability-diffusion.html
$base64_image_data = "";
try {
$modelId = 'stability.stable-diffusion-xl-v1';
$body = [
'text_prompts' => [
['text' => $prompt]
],
'seed' => $seed,
'cfg_scale' => 10,
'steps' => 30
];
if ($style_preset) {
$body['style_preset'] = $style_preset;
}
$result = $this->bedrockRuntimeClient->invokeModel([
'contentType' => 'application/json',
'body' => json_encode($body),
'modelId' => $modelId,
]);
$response_body = json_decode($result['body']);
$base64_image_data = $response_body->artifacts[0]->base64;
} catch (Exception $e) {
echo "Error: ({$e->getCode()}) - {$e->getMessage()}\n";
}
return $base64_image_data;
}
```
+ Per i dettagli sull'API, [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)consulta *AWS SDK per PHP API Reference*.
# Esempi per Amazon DocumentDB con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando Amazon DocumentDB. AWS SDK per PHP
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**
+ [Esempi serverless](#serverless_examples)
## Esempi serverless
### Invocare una funzione Lambda da un trigger Amazon DocumentDB
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di record da un flusso di modifiche di DocumentDB. La funzione recupera il payload DocumentDB e registra il contenuto del record.
**SDK per PHP**
C'è di più su. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Utilizzo di un evento Amazon DocumentDB con Lambda tramite PHP.
```
logDocumentDBEvent($record['event']);
}
return 'OK';
}
private function logDocumentDBEvent($event): void
{
// Extract information from the event record
$operationType = $event['operationType'] ?? 'Unknown';
$db = $event['ns']['db'] ?? 'Unknown';
$collection = $event['ns']['coll'] ?? 'Unknown';
$fullDocument = $event['fullDocument'] ?? [];
// Log the event details
echo "Operation type: $operationType\n";
echo "Database: $db\n";
echo "Collection: $collection\n";
echo "Full document: " . json_encode($fullDocument, JSON_PRETTY_PRINT) . "\n";
}
}
return new DocumentDBEventHandler();
```
# Esempi per DynamoDB con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP con DynamoDB.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
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**
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
+ [Scenari](#scenarios)
+ [Esempi serverless](#serverless_examples)
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come:
+ Crea una tabella in grado di contenere i dati del filmato.
+ Inserire, ottenere e aggiornare un singolo filmato nella tabella.
+ Scrivere i dati del filmato nella tabella da un file JSON di esempio.
+ Eseguire una query sui filmati che sono stati rilasciati in un dato anno.
+ Cerca i filmati che sono stati distribuiti in diversi anni.
+ Elimina un filmato dalla tabella, quindi elimina la tabella.
**SDK per PHP**
C'è di più 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/php/example_code/dynamodb#code-examples).
Poiché questo esempio utilizza file di supporto, assicurati di [leggere le indicazioni](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/php/README.md#prerequisites) contenute nel file README.md degli esempi PHP.
```
namespace DynamoDb\Basics;
use Aws\DynamoDb\Marshaler;
use DynamoDb;
use DynamoDb\DynamoDBAttribute;
use DynamoDb\DynamoDBService;
use function AwsUtilities\loadMovieData;
use function AwsUtilities\testable_readline;
class GettingStartedWithDynamoDB
{
public function run()
{
echo("\n");
echo("--------------------------------------\n");
print("Welcome to the Amazon DynamoDB getting started demo using PHP!\n");
echo("--------------------------------------\n");
$uuid = uniqid();
$service = new DynamoDBService();
$tableName = "ddb_demo_table_$uuid";
$service->createTable(
$tableName,
[
new DynamoDBAttribute('year', 'N', 'HASH'),
new DynamoDBAttribute('title', 'S', 'RANGE')
]
);
echo "Waiting for table...";
$service->dynamoDbClient->waitUntil("TableExists", ['TableName' => $tableName]);
echo "table $tableName found!\n";
echo "What's the name of the last movie you watched?\n";
while (empty($movieName)) {
$movieName = testable_readline("Movie name: ");
}
echo "And what year was it released?\n";
$movieYear = "year";
while (!is_numeric($movieYear) || intval($movieYear) != $movieYear) {
$movieYear = testable_readline("Year released: ");
}
$service->putItem([
'Item' => [
'year' => [
'N' => "$movieYear",
],
'title' => [
'S' => $movieName,
],
],
'TableName' => $tableName,
]);
echo "How would you rate the movie from 1-10?\n";
$rating = 0;
while (!is_numeric($rating) || intval($rating) != $rating || $rating < 1 || $rating > 10) {
$rating = testable_readline("Rating (1-10): ");
}
echo "What was the movie about?\n";
while (empty($plot)) {
$plot = testable_readline("Plot summary: ");
}
$key = [
'Item' => [
'title' => [
'S' => $movieName,
],
'year' => [
'N' => $movieYear,
],
]
];
$attributes = ["rating" =>
[
'AttributeName' => 'rating',
'AttributeType' => 'N',
'Value' => $rating,
],
'plot' => [
'AttributeName' => 'plot',
'AttributeType' => 'S',
'Value' => $plot,
]
];
$service->updateItemAttributesByKey($tableName, $key, $attributes);
echo "Movie added and updated.";
$batch = json_decode(loadMovieData());
$service->writeBatch($tableName, $batch);
$movie = $service->getItemByKey($tableName, $key);
echo "\nThe movie {$movie['Item']['title']['S']} was released in {$movie['Item']['year']['N']}.\n";
echo "What rating would you like to give {$movie['Item']['title']['S']}?\n";
$rating = 0;
while (!is_numeric($rating) || intval($rating) != $rating || $rating < 1 || $rating > 10) {
$rating = testable_readline("Rating (1-10): ");
}
$service->updateItemAttributeByKey($tableName, $key, 'rating', 'N', $rating);
$movie = $service->getItemByKey($tableName, $key);
echo "Ok, you have rated {$movie['Item']['title']['S']} as a {$movie['Item']['rating']['N']}\n";
$service->deleteItemByKey($tableName, $key);
echo "But, bad news, this was a trap. That movie has now been deleted because of your rating...harsh.\n";
echo "That's okay though. The book was better. Now, for something lighter, in what year were you born?\n";
$birthYear = "not a number";
while (!is_numeric($birthYear) || $birthYear >= date("Y")) {
$birthYear = testable_readline("Birth year: ");
}
$birthKey = [
'Key' => [
'year' => [
'N' => "$birthYear",
],
],
];
$result = $service->query($tableName, $birthKey);
$marshal = new Marshaler();
echo "Here are the movies in our collection released the year you were born:\n";
$oops = "Oops! There were no movies released in that year (that we know of).\n";
$display = "";
foreach ($result['Items'] as $movie) {
$movie = $marshal->unmarshalItem($movie);
$display .= $movie['title'] . "\n";
}
echo ($display) ?: $oops;
$yearsKey = [
'Key' => [
'year' => [
'N' => [
'minRange' => 1990,
'maxRange' => 1999,
],
],
],
];
$filter = "year between 1990 and 1999";
echo "\nHere's a list of all the movies released in the 90s:\n";
$result = $service->scan($tableName, $yearsKey, $filter);
foreach ($result['Items'] as $movie) {
$movie = $marshal->unmarshalItem($movie);
echo $movie['title'] . "\n";
}
echo "\nCleaning up this demo by deleting table $tableName...\n";
$service->deleteTable($tableName);
}
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per PHP *.
+ [BatchWriteItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/BatchWriteItem)
+ [CreateTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/CreateTable)
+ [DeleteItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DeleteItem)
+ [DeleteTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DeleteTable)
+ [DescribeTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DescribeTable)
+ [GetItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/GetItem)
+ [PutItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/PutItem)
+ [Query](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Query)
+ [Scan](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Scan)
+ [UpdateItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/UpdateItem)
## Azioni
### `BatchExecuteStatement`
Il seguente esempio di codice mostra come usare`BatchExecuteStatement`.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
public function getItemByPartiQLBatch(string $tableName, array $keys): Result
{
$statements = [];
foreach ($keys as $key) {
list($statement, $parameters) = $this->buildStatementAndParameters("SELECT", $tableName, $key['Item']);
$statements[] = [
'Statement' => "$statement",
'Parameters' => $parameters,
];
}
return $this->dynamoDbClient->batchExecuteStatement([
'Statements' => $statements,
]);
}
public function insertItemByPartiQLBatch(string $statement, array $parameters)
{
$this->dynamoDbClient->batchExecuteStatement([
'Statements' => [
[
'Statement' => "$statement",
'Parameters' => $parameters,
],
],
]);
}
public function updateItemByPartiQLBatch(string $statement, array $parameters)
{
$this->dynamoDbClient->batchExecuteStatement([
'Statements' => [
[
'Statement' => "$statement",
'Parameters' => $parameters,
],
],
]);
}
public function deleteItemByPartiQLBatch(string $statement, array $parameters)
{
$this->dynamoDbClient->batchExecuteStatement([
'Statements' => [
[
'Statement' => "$statement",
'Parameters' => $parameters,
],
],
]);
}
```
+ Per i dettagli sull'API, [BatchExecuteStatement](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/BatchExecuteStatement)consulta *AWS SDK per PHP API Reference*.
### `BatchWriteItem`
Il seguente esempio di codice mostra come utilizzare`BatchWriteItem`.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
public function writeBatch(string $TableName, array $Batch, int $depth = 2)
{
if (--$depth <= 0) {
throw new Exception("Max depth exceeded. Please try with fewer batch items or increase depth.");
}
$marshal = new Marshaler();
$total = 0;
foreach (array_chunk($Batch, 25) as $Items) {
foreach ($Items as $Item) {
$BatchWrite['RequestItems'][$TableName][] = ['PutRequest' => ['Item' => $marshal->marshalItem($Item)]];
}
try {
echo "Batching another " . count($Items) . " for a total of " . ($total += count($Items)) . " items!\n";
$response = $this->dynamoDbClient->batchWriteItem($BatchWrite);
$BatchWrite = [];
} catch (Exception $e) {
echo "uh oh...";
echo $e->getMessage();
die();
}
if ($total >= 250) {
echo "250 movies is probably enough. Right? We can stop there.\n";
break;
}
}
}
```
+ Per i dettagli sull'API, [BatchWriteItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/BatchWriteItem)consulta *AWS SDK per PHP API Reference*.
### `CreateTable`
Il seguente esempio di codice mostra come utilizzare`CreateTable`.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
Creare una tabella.
```
$tableName = "ddb_demo_table_$uuid";
$service->createTable(
$tableName,
[
new DynamoDBAttribute('year', 'N', 'HASH'),
new DynamoDBAttribute('title', 'S', 'RANGE')
]
);
public function createTable(string $tableName, array $attributes)
{
$keySchema = [];
$attributeDefinitions = [];
foreach ($attributes as $attribute) {
if (is_a($attribute, DynamoDBAttribute::class)) {
$keySchema[] = ['AttributeName' => $attribute->AttributeName, 'KeyType' => $attribute->KeyType];
$attributeDefinitions[] =
['AttributeName' => $attribute->AttributeName, 'AttributeType' => $attribute->AttributeType];
}
}
$this->dynamoDbClient->createTable([
'TableName' => $tableName,
'KeySchema' => $keySchema,
'AttributeDefinitions' => $attributeDefinitions,
'ProvisionedThroughput' => ['ReadCapacityUnits' => 10, 'WriteCapacityUnits' => 10],
]);
}
```
+ Per i dettagli sull'API, [CreateTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/CreateTable)consulta *AWS SDK per PHP API Reference*.
### `DeleteItem`
Il seguente esempio di codice mostra come utilizzare`DeleteItem`.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
$key = [
'Item' => [
'title' => [
'S' => $movieName,
],
'year' => [
'N' => $movieYear,
],
]
];
$service->deleteItemByKey($tableName, $key);
echo "But, bad news, this was a trap. That movie has now been deleted because of your rating...harsh.\n";
public function deleteItemByKey(string $tableName, array $key)
{
$this->dynamoDbClient->deleteItem([
'Key' => $key['Item'],
'TableName' => $tableName,
]);
}
```
+ Per i dettagli sull'API, [DeleteItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DeleteItem)consulta *AWS SDK per PHP API Reference*.
### `DeleteTable`
Il seguente esempio di codice mostra come utilizzare`DeleteTable`.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
public function deleteTable(string $TableName)
{
$this->customWaiter(function () use ($TableName) {
return $this->dynamoDbClient->deleteTable([
'TableName' => $TableName,
]);
});
}
```
+ Per i dettagli sull'API, [DeleteTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DeleteTable)consulta *AWS SDK per PHP API Reference*.
### `ExecuteStatement`
Il seguente esempio di codice mostra come utilizzare`ExecuteStatement`.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
public function insertItemByPartiQL(string $statement, array $parameters)
{
$this->dynamoDbClient->executeStatement([
'Statement' => "$statement",
'Parameters' => $parameters,
]);
}
public function getItemByPartiQL(string $tableName, array $key): Result
{
list($statement, $parameters) = $this->buildStatementAndParameters("SELECT", $tableName, $key['Item']);
return $this->dynamoDbClient->executeStatement([
'Parameters' => $parameters,
'Statement' => $statement,
]);
}
public function updateItemByPartiQL(string $statement, array $parameters)
{
$this->dynamoDbClient->executeStatement([
'Statement' => $statement,
'Parameters' => $parameters,
]);
}
public function deleteItemByPartiQL(string $statement, array $parameters)
{
$this->dynamoDbClient->executeStatement([
'Statement' => $statement,
'Parameters' => $parameters,
]);
}
```
+ Per i dettagli sull'API, [ExecuteStatement](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/ExecuteStatement)consulta *AWS SDK per PHP API Reference*.
### `GetItem`
Il seguente esempio di codice mostra come utilizzare`GetItem`.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
$movie = $service->getItemByKey($tableName, $key);
echo "\nThe movie {$movie['Item']['title']['S']} was released in {$movie['Item']['year']['N']}.\n";
public function getItemByKey(string $tableName, array $key)
{
return $this->dynamoDbClient->getItem([
'Key' => $key['Item'],
'TableName' => $tableName,
]);
}
```
+ Per i dettagli sull'API, [GetItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/GetItem)consulta *AWS SDK per PHP API Reference*.
### `ListTables`
Il seguente esempio di codice mostra come utilizzare`ListTables`.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
public function listTables($exclusiveStartTableName = "", $limit = 100)
{
$this->dynamoDbClient->listTables([
'ExclusiveStartTableName' => $exclusiveStartTableName,
'Limit' => $limit,
]);
}
```
+ Per i dettagli sull'API, [ListTables](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/ListTables)consulta *AWS SDK per PHP API Reference*.
### `PutItem`
Il seguente esempio di codice mostra come utilizzare`PutItem`.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
echo "What's the name of the last movie you watched?\n";
while (empty($movieName)) {
$movieName = testable_readline("Movie name: ");
}
echo "And what year was it released?\n";
$movieYear = "year";
while (!is_numeric($movieYear) || intval($movieYear) != $movieYear) {
$movieYear = testable_readline("Year released: ");
}
$service->putItem([
'Item' => [
'year' => [
'N' => "$movieYear",
],
'title' => [
'S' => $movieName,
],
],
'TableName' => $tableName,
]);
public function putItem(array $array)
{
$this->dynamoDbClient->putItem($array);
}
```
+ Per i dettagli sull'API, [PutItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/PutItem)consulta *AWS SDK per PHP API Reference*.
### `Query`
Il seguente esempio di codice mostra come utilizzare`Query`.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
$birthKey = [
'Key' => [
'year' => [
'N' => "$birthYear",
],
],
];
$result = $service->query($tableName, $birthKey);
public function query(string $tableName, $key)
{
$expressionAttributeValues = [];
$expressionAttributeNames = [];
$keyConditionExpression = "";
$index = 1;
foreach ($key as $name => $value) {
$keyConditionExpression .= "#" . array_key_first($value) . " = :v$index,";
$expressionAttributeNames["#" . array_key_first($value)] = array_key_first($value);
$hold = array_pop($value);
$expressionAttributeValues[":v$index"] = [
array_key_first($hold) => array_pop($hold),
];
}
$keyConditionExpression = substr($keyConditionExpression, 0, -1);
$query = [
'ExpressionAttributeValues' => $expressionAttributeValues,
'ExpressionAttributeNames' => $expressionAttributeNames,
'KeyConditionExpression' => $keyConditionExpression,
'TableName' => $tableName,
];
return $this->dynamoDbClient->query($query);
}
```
+ Per informazioni dettagliate sull’API, consulta [Query](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Query) nella *documentazione di riferimento dell’API AWS SDK per PHP *.
### `Scan`
Il seguente esempio di codice mostra come usare`Scan`.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
$yearsKey = [
'Key' => [
'year' => [
'N' => [
'minRange' => 1990,
'maxRange' => 1999,
],
],
],
];
$filter = "year between 1990 and 1999";
echo "\nHere's a list of all the movies released in the 90s:\n";
$result = $service->scan($tableName, $yearsKey, $filter);
foreach ($result['Items'] as $movie) {
$movie = $marshal->unmarshalItem($movie);
echo $movie['title'] . "\n";
}
public function scan(string $tableName, array $key, string $filters)
{
$query = [
'ExpressionAttributeNames' => ['#year' => 'year'],
'ExpressionAttributeValues' => [
":min" => ['N' => '1990'],
":max" => ['N' => '1999'],
],
'FilterExpression' => "#year between :min and :max",
'TableName' => $tableName,
];
return $this->dynamoDbClient->scan($query);
}
```
+ Per informazioni dettagliate sull’API, consulta [Scan](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Scan) nella *documentazione di riferimento dell’API AWS SDK per PHP *.
### `UpdateItem`
Il seguente esempio di codice mostra come usare`UpdateItem`.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
echo "What rating would you like to give {$movie['Item']['title']['S']}?\n";
$rating = 0;
while (!is_numeric($rating) || intval($rating) != $rating || $rating < 1 || $rating > 10) {
$rating = testable_readline("Rating (1-10): ");
}
$service->updateItemAttributeByKey($tableName, $key, 'rating', 'N', $rating);
public function updateItemAttributeByKey(
string $tableName,
array $key,
string $attributeName,
string $attributeType,
string $newValue
) {
$this->dynamoDbClient->updateItem([
'Key' => $key['Item'],
'TableName' => $tableName,
'UpdateExpression' => "set #NV=:NV",
'ExpressionAttributeNames' => [
'#NV' => $attributeName,
],
'ExpressionAttributeValues' => [
':NV' => [
$attributeType => $newValue
]
],
]);
}
```
+ Per i dettagli sull'API, [UpdateItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/UpdateItem)consulta *AWS SDK per PHP API Reference*.
## Scenari
### Creazione di un’applicazione serverless per gestire foto
L’esempio di codice seguente mostra come creare un’applicazione serverless che consente agli utenti di gestire le foto mediante etichette.
**SDK per PHP**
Mostra come sviluppare un’applicazione per la gestione delle risorse fotografiche che rileva le etichette nelle immagini utilizzando Amazon Rekognition e le archivia per recuperarle in seguito.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Per approfondire l’origine di questo esempio, consulta il post su [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servizi utilizzati in questo esempio**
+ Gateway API
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Simple Storage Service (Amazon S3)
+ Amazon SNS
### Esecuzione di una query su una tabella mediante batch di istruzioni PartiQL
L’esempio di codice seguente mostra come:
+ Ricezione di un batch di elementi mediante più istruzioni SELECT.
+ Aggiunta di un batch di articoli eseguendo più istruzioni INSERT.
+ Aggiornamento di un batch di elementi mediante più istruzioni UPDATE.
+ Eliminazione di un batch di elementi mediante più istruzioni DELETE.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
namespace DynamoDb\PartiQL_Basics;
use Aws\DynamoDb\Marshaler;
use DynamoDb;
use DynamoDb\DynamoDBAttribute;
use function AwsUtilities\loadMovieData;
use function AwsUtilities\testable_readline;
class GettingStartedWithPartiQLBatch
{
public function run()
{
echo("\n");
echo("--------------------------------------\n");
print("Welcome to the Amazon DynamoDB - PartiQL getting started demo using PHP!\n");
echo("--------------------------------------\n");
$uuid = uniqid();
$service = new DynamoDb\DynamoDBService();
$tableName = "partiql_demo_table_$uuid";
$service->createTable(
$tableName,
[
new DynamoDBAttribute('year', 'N', 'HASH'),
new DynamoDBAttribute('title', 'S', 'RANGE')
]
);
echo "Waiting for table...";
$service->dynamoDbClient->waitUntil("TableExists", ['TableName' => $tableName]);
echo "table $tableName found!\n";
echo "What's the name of the last movie you watched?\n";
while (empty($movieName)) {
$movieName = testable_readline("Movie name: ");
}
echo "And what year was it released?\n";
$movieYear = "year";
while (!is_numeric($movieYear) || intval($movieYear) != $movieYear) {
$movieYear = testable_readline("Year released: ");
}
$key = [
'Item' => [
'year' => [
'N' => "$movieYear",
],
'title' => [
'S' => $movieName,
],
],
];
list($statement, $parameters) = $service->buildStatementAndParameters("INSERT", $tableName, $key);
$service->insertItemByPartiQLBatch($statement, $parameters);
echo "How would you rate the movie from 1-10?\n";
$rating = 0;
while (!is_numeric($rating) || intval($rating) != $rating || $rating < 1 || $rating > 10) {
$rating = testable_readline("Rating (1-10): ");
}
echo "What was the movie about?\n";
while (empty($plot)) {
$plot = testable_readline("Plot summary: ");
}
$attributes = [
new DynamoDBAttribute('rating', 'N', 'HASH', $rating),
new DynamoDBAttribute('plot', 'S', 'RANGE', $plot),
];
list($statement, $parameters) = $service->buildStatementAndParameters("UPDATE", $tableName, $key, $attributes);
$service->updateItemByPartiQLBatch($statement, $parameters);
echo "Movie added and updated.\n";
$batch = json_decode(loadMovieData());
$service->writeBatch($tableName, $batch);
$movie = $service->getItemByPartiQLBatch($tableName, [$key]);
echo "\nThe movie {$movie['Responses'][0]['Item']['title']['S']}
was released in {$movie['Responses'][0]['Item']['year']['N']}.\n";
echo "What rating would you like to give {$movie['Responses'][0]['Item']['title']['S']}?\n";
$rating = 0;
while (!is_numeric($rating) || intval($rating) != $rating || $rating < 1 || $rating > 10) {
$rating = testable_readline("Rating (1-10): ");
}
$attributes = [
new DynamoDBAttribute('rating', 'N', 'HASH', $rating),
new DynamoDBAttribute('plot', 'S', 'RANGE', $plot)
];
list($statement, $parameters) = $service->buildStatementAndParameters("UPDATE", $tableName, $key, $attributes);
$service->updateItemByPartiQLBatch($statement, $parameters);
$movie = $service->getItemByPartiQLBatch($tableName, [$key]);
echo "Okay, you have rated {$movie['Responses'][0]['Item']['title']['S']}
as a {$movie['Responses'][0]['Item']['rating']['N']}\n";
$service->deleteItemByPartiQLBatch($statement, $parameters);
echo "But, bad news, this was a trap. That movie has now been deleted because of your rating...harsh.\n";
echo "That's okay though. The book was better. Now, for something lighter, in what year were you born?\n";
$birthYear = "not a number";
while (!is_numeric($birthYear) || $birthYear >= date("Y")) {
$birthYear = testable_readline("Birth year: ");
}
$birthKey = [
'Key' => [
'year' => [
'N' => "$birthYear",
],
],
];
$result = $service->query($tableName, $birthKey);
$marshal = new Marshaler();
echo "Here are the movies in our collection released the year you were born:\n";
$oops = "Oops! There were no movies released in that year (that we know of).\n";
$display = "";
foreach ($result['Items'] as $movie) {
$movie = $marshal->unmarshalItem($movie);
$display .= $movie['title'] . "\n";
}
echo ($display) ?: $oops;
$yearsKey = [
'Key' => [
'year' => [
'N' => [
'minRange' => 1990,
'maxRange' => 1999,
],
],
],
];
$filter = "year between 1990 and 1999";
echo "\nHere's a list of all the movies released in the 90s:\n";
$result = $service->scan($tableName, $yearsKey, $filter);
foreach ($result['Items'] as $movie) {
$movie = $marshal->unmarshalItem($movie);
echo $movie['title'] . "\n";
}
echo "\nCleaning up this demo by deleting table $tableName...\n";
$service->deleteTable($tableName);
}
}
public function insertItemByPartiQLBatch(string $statement, array $parameters)
{
$this->dynamoDbClient->batchExecuteStatement([
'Statements' => [
[
'Statement' => "$statement",
'Parameters' => $parameters,
],
],
]);
}
public function getItemByPartiQLBatch(string $tableName, array $keys): Result
{
$statements = [];
foreach ($keys as $key) {
list($statement, $parameters) = $this->buildStatementAndParameters("SELECT", $tableName, $key['Item']);
$statements[] = [
'Statement' => "$statement",
'Parameters' => $parameters,
];
}
return $this->dynamoDbClient->batchExecuteStatement([
'Statements' => $statements,
]);
}
public function updateItemByPartiQLBatch(string $statement, array $parameters)
{
$this->dynamoDbClient->batchExecuteStatement([
'Statements' => [
[
'Statement' => "$statement",
'Parameters' => $parameters,
],
],
]);
}
public function deleteItemByPartiQLBatch(string $statement, array $parameters)
{
$this->dynamoDbClient->batchExecuteStatement([
'Statements' => [
[
'Statement' => "$statement",
'Parameters' => $parameters,
],
],
]);
}
```
+ Per i dettagli sull'API, [BatchExecuteStatement](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/BatchExecuteStatement)consulta *AWS SDK per PHP API Reference*.
### Esecuzione di una query mediante PartiQL
L’esempio di codice seguente mostra come:
+ Ricezione di un articolo eseguendo un’istruzione SELECT.
+ Aggiunta di un elemento eseguendo un’istruzione INSERT.
+ Aggiornamento di un elemento eseguendo un’istruzione UPDATE.
+ Eliminazione di un elemento eseguendo un’istruzione DELETE.
**SDK per PHP**
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/php/example_code/dynamodb#code-examples).
```
namespace DynamoDb\PartiQL_Basics;
use Aws\DynamoDb\Marshaler;
use DynamoDb;
use DynamoDb\DynamoDBAttribute;
use function AwsUtilities\testable_readline;
use function AwsUtilities\loadMovieData;
class GettingStartedWithPartiQL
{
public function run()
{
echo("\n");
echo("--------------------------------------\n");
print("Welcome to the Amazon DynamoDB - PartiQL getting started demo using PHP!\n");
echo("--------------------------------------\n");
$uuid = uniqid();
$service = new DynamoDb\DynamoDBService();
$tableName = "partiql_demo_table_$uuid";
$service->createTable(
$tableName,
[
new DynamoDBAttribute('year', 'N', 'HASH'),
new DynamoDBAttribute('title', 'S', 'RANGE')
]
);
echo "Waiting for table...";
$service->dynamoDbClient->waitUntil("TableExists", ['TableName' => $tableName]);
echo "table $tableName found!\n";
echo "What's the name of the last movie you watched?\n";
while (empty($movieName)) {
$movieName = testable_readline("Movie name: ");
}
echo "And what year was it released?\n";
$movieYear = "year";
while (!is_numeric($movieYear) || intval($movieYear) != $movieYear) {
$movieYear = testable_readline("Year released: ");
}
$key = [
'Item' => [
'year' => [
'N' => "$movieYear",
],
'title' => [
'S' => $movieName,
],
],
];
list($statement, $parameters) = $service->buildStatementAndParameters("INSERT", $tableName, $key);
$service->insertItemByPartiQL($statement, $parameters);
echo "How would you rate the movie from 1-10?\n";
$rating = 0;
while (!is_numeric($rating) || intval($rating) != $rating || $rating < 1 || $rating > 10) {
$rating = testable_readline("Rating (1-10): ");
}
echo "What was the movie about?\n";
while (empty($plot)) {
$plot = testable_readline("Plot summary: ");
}
$attributes = [
new DynamoDBAttribute('rating', 'N', 'HASH', $rating),
new DynamoDBAttribute('plot', 'S', 'RANGE', $plot),
];
list($statement, $parameters) = $service->buildStatementAndParameters("UPDATE", $tableName, $key, $attributes);
$service->updateItemByPartiQL($statement, $parameters);
echo "Movie added and updated.\n";
$batch = json_decode(loadMovieData());
$service->writeBatch($tableName, $batch);
$movie = $service->getItemByPartiQL($tableName, $key);
echo "\nThe movie {$movie['Items'][0]['title']['S']} was released in {$movie['Items'][0]['year']['N']}.\n";
echo "What rating would you like to give {$movie['Items'][0]['title']['S']}?\n";
$rating = 0;
while (!is_numeric($rating) || intval($rating) != $rating || $rating < 1 || $rating > 10) {
$rating = testable_readline("Rating (1-10): ");
}
$attributes = [
new DynamoDBAttribute('rating', 'N', 'HASH', $rating),
new DynamoDBAttribute('plot', 'S', 'RANGE', $plot)
];
list($statement, $parameters) = $service->buildStatementAndParameters("UPDATE", $tableName, $key, $attributes);
$service->updateItemByPartiQL($statement, $parameters);
$movie = $service->getItemByPartiQL($tableName, $key);
echo "Okay, you have rated {$movie['Items'][0]['title']['S']} as a {$movie['Items'][0]['rating']['N']}\n";
$service->deleteItemByPartiQL($statement, $parameters);
echo "But, bad news, this was a trap. That movie has now been deleted because of your rating...harsh.\n";
echo "That's okay though. The book was better. Now, for something lighter, in what year were you born?\n";
$birthYear = "not a number";
while (!is_numeric($birthYear) || $birthYear >= date("Y")) {
$birthYear = testable_readline("Birth year: ");
}
$birthKey = [
'Key' => [
'year' => [
'N' => "$birthYear",
],
],
];
$result = $service->query($tableName, $birthKey);
$marshal = new Marshaler();
echo "Here are the movies in our collection released the year you were born:\n";
$oops = "Oops! There were no movies released in that year (that we know of).\n";
$display = "";
foreach ($result['Items'] as $movie) {
$movie = $marshal->unmarshalItem($movie);
$display .= $movie['title'] . "\n";
}
echo ($display) ?: $oops;
$yearsKey = [
'Key' => [
'year' => [
'N' => [
'minRange' => 1990,
'maxRange' => 1999,
],
],
],
];
$filter = "year between 1990 and 1999";
echo "\nHere's a list of all the movies released in the 90s:\n";
$result = $service->scan($tableName, $yearsKey, $filter);
foreach ($result['Items'] as $movie) {
$movie = $marshal->unmarshalItem($movie);
echo $movie['title'] . "\n";
}
echo "\nCleaning up this demo by deleting table $tableName...\n";
$service->deleteTable($tableName);
}
}
public function insertItemByPartiQL(string $statement, array $parameters)
{
$this->dynamoDbClient->executeStatement([
'Statement' => "$statement",
'Parameters' => $parameters,
]);
}
public function getItemByPartiQL(string $tableName, array $key): Result
{
list($statement, $parameters) = $this->buildStatementAndParameters("SELECT", $tableName, $key['Item']);
return $this->dynamoDbClient->executeStatement([
'Parameters' => $parameters,
'Statement' => $statement,
]);
}
public function updateItemByPartiQL(string $statement, array $parameters)
{
$this->dynamoDbClient->executeStatement([
'Statement' => $statement,
'Parameters' => $parameters,
]);
}
public function deleteItemByPartiQL(string $statement, array $parameters)
{
$this->dynamoDbClient->executeStatement([
'Statement' => $statement,
'Parameters' => $parameters,
]);
}
```
+ Per i dettagli sull'API, [ExecuteStatement](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/ExecuteStatement)consulta *AWS SDK per PHP API Reference*.
## Esempi serverless
### Invocare una funzione Lambda da un trigger DynamoDB
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di record da un flusso DynamoDB. La funzione recupera il payload DynamoDB e registra il contenuto del record.
**SDK per PHP**
C'è altro su GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda).
Utilizzo di un evento DynamoDB con Lambda tramite PHP.
```
logger = $logger;
}
/**
* @throws JsonException
* @throws \Bref\Event\InvalidLambdaEvent
*/
public function handleDynamoDb(DynamoDbEvent $event, Context $context): void
{
$this->logger->info("Processing DynamoDb table items");
$records = $event->getRecords();
foreach ($records as $record) {
$eventName = $record->getEventName();
$keys = $record->getKeys();
$old = $record->getOldImage();
$new = $record->getNewImage();
$this->logger->info("Event Name:".$eventName."\n");
$this->logger->info("Keys:". json_encode($keys)."\n");
$this->logger->info("Old Image:". json_encode($old)."\n");
$this->logger->info("New Image:". json_encode($new));
// TODO: Do interesting work based on the new data
// Any exception thrown will be logged and the invocation will be marked as failed
}
$totalRecords = count($records);
$this->logger->info("Successfully processed $totalRecords items");
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
### Segnalazione di errori di elementi batch per funzioni Lambda con un trigger DynamoDB
L’esempio di codice seguente mostra come implementare una risposta batch parziale per funzioni Lambda che ricevono eventi da un flusso DynamoDB. La funzione riporta gli errori degli elementi batch nella risposta, segnalando a Lambda di riprovare tali messaggi in un secondo momento.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda-with-batch-item-handling).
Segnalazione di errori di elementi batch di DynamoDB con Lambda tramite PHP.
```
logger = $logger;
}
/**
* @throws JsonException
* @throws \Bref\Event\InvalidLambdaEvent
*/
public function handle(mixed $event, Context $context): array
{
$dynamoDbEvent = new DynamoDbEvent($event);
$this->logger->info("Processing records");
$records = $dynamoDbEvent->getRecords();
$failedRecords = [];
foreach ($records as $record) {
try {
$data = $record->getData();
$this->logger->info(json_encode($data));
// TODO: Do interesting work based on the new data
} catch (Exception $e) {
$this->logger->error($e->getMessage());
// failed processing the record
$failedRecords[] = $record->getSequenceNumber();
}
}
$totalRecords = count($records);
$this->logger->info("Successfully processed $totalRecords records");
// change format for the response
$failures = array_map(
fn(string $sequenceNumber) => ['itemIdentifier' => $sequenceNumber],
$failedRecords
);
return [
'batchItemFailures' => $failures
];
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
# EC2 Esempi di Amazon che utilizzano SDK for PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando il AWS SDK per PHP con Amazon EC2.
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.
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)
## Azioni
### `CreateVpc`
Il seguente esempio di codice mostra come usare`CreateVpc`.
**SDK per PHP**
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/php/example_code/ec2#code-examples).
```
/**
* @param string $cidr
* @return array
*/
public function createVpc(string $cidr): array
{
try {
$result = $this->ec2Client->createVpc([
"CidrBlock" => $cidr,
]);
return $result['Vpc'];
}catch(Ec2Exception $caught){
echo "There was a problem creating the VPC: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
```
+ Per i dettagli sull'API, [CreateVpc](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/CreateVpc)consulta *AWS SDK per PHP API Reference*.
### `CreateVpcEndpoint`
Il seguente esempio di codice mostra come utilizzare`CreateVpcEndpoint`.
**SDK per PHP**
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/php/example_code/ec2#code-examples).
```
/**
* @param string $serviceName
* @param string $vpcId
* @param array $routeTableIds
* @return array
*/
public function createVpcEndpoint(string $serviceName, string $vpcId, array $routeTableIds): array
{
try {
$result = $this->ec2Client->createVpcEndpoint([
'ServiceName' => $serviceName,
'VpcId' => $vpcId,
'RouteTableIds' => $routeTableIds,
]);
return $result["VpcEndpoint"];
} catch(Ec2Exception $caught){
echo "There was a problem creating the VPC Endpoint: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
```
+ Per i dettagli sull'API, [CreateVpcEndpoint](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/CreateVpcEndpoint)consulta *AWS SDK per PHP API Reference*.
### `DeleteVpc`
Il seguente esempio di codice mostra come utilizzare`DeleteVpc`.
**SDK per PHP**
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/php/example_code/ec2#code-examples).
```
/**
* @param string $vpcId
* @return void
*/
public function deleteVpc(string $vpcId)
{
try {
$this->ec2Client->deleteVpc([
"VpcId" => $vpcId,
]);
}catch(Ec2Exception $caught){
echo "There was a problem deleting the VPC: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
```
+ Per i dettagli sull'API, [DeleteVpc](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/DeleteVpc)consulta *AWS SDK per PHP API Reference*.
### `DeleteVpcEndpoints`
Il seguente esempio di codice mostra come utilizzare`DeleteVpcEndpoints`.
**SDK per PHP**
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/php/example_code/ec2#code-examples).
```
/**
* @param string $vpcEndpointId
* @return void
*/
public function deleteVpcEndpoint(string $vpcEndpointId)
{
try {
$this->ec2Client->deleteVpcEndpoints([
"VpcEndpointIds" => [$vpcEndpointId],
]);
}catch (Ec2Exception $caught){
echo "There was a problem deleting the VPC Endpoint: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
```
+ Per i dettagli sull'API, [DeleteVpcEndpoints](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/DeleteVpcEndpoints)consulta *AWS SDK per PHP API Reference*.
### `DescribeRouteTables`
Il seguente esempio di codice mostra come utilizzare`DescribeRouteTables`.
**SDK per PHP**
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/php/example_code/ec2#code-examples).
```
/**
* @param array $routeTableIds
* @param array $filters
* @return array
*/
public function describeRouteTables(array $routeTableIds = [], array $filters = []): array
{
$parameters = [];
if($routeTableIds){
$parameters['RouteTableIds'] = $routeTableIds;
}
if($filters){
$parameters['Filters'] = $filters;
}
try {
$paginator = $this->ec2Client->getPaginator("DescribeRouteTables", $parameters);
$contents = [];
foreach ($paginator as $result) {
foreach ($result['RouteTables'] as $object) {
$contents[] = $object['RouteTableId'];
}
}
}catch (Ec2Exception $caught){
echo "There was a problem paginating the results of DescribeRouteTables: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
return $contents;
}
```
+ Per i dettagli sull'API, [DescribeRouteTables](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/DescribeRouteTables)consulta *AWS SDK per PHP API Reference*.
# AWS Glue esempi che utilizzano SDK for PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP with AWS Glue.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
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.
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**
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come:
+ Crea un crawler che esegue la scansione di un bucket Amazon S3 pubblico e genera un database di metadati in formato CSV.
+ Elenca le informazioni su database e tabelle in AWS Glue Data Catalog.
+ Crea un processo per estrarre i dati CSV dal bucket S3, trasformare i dati e caricare l’output in formato JSON in un altro bucket S3.
+ Elenca le informazioni sulle esecuzioni dei processi, visualizza i dati trasformati e pulisci le risorse.
Per ulteriori informazioni, consulta [Tutorial: Guida introduttiva a AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/ug/tutorial-create-job.html).
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
namespace Glue;
use Aws\Glue\GlueClient;
use Aws\S3\S3Client;
use AwsUtilities\AWSServiceClass;
use GuzzleHttp\Psr7\Stream;
use Iam\IAMService;
class GettingStartedWithGlue
{
public function run()
{
echo("\n");
echo("--------------------------------------\n");
print("Welcome to the AWS Glue getting started demo using PHP!\n");
echo("--------------------------------------\n");
$clientArgs = [
'region' => 'us-west-2',
'version' => 'latest',
'profile' => 'default',
];
$uniqid = uniqid();
$glueClient = new GlueClient($clientArgs);
$glueService = new GlueService($glueClient);
$iamService = new IAMService();
$crawlerName = "example-crawler-test-" . $uniqid;
AWSServiceClass::$waitTime = 5;
AWSServiceClass::$maxWaitAttempts = 20;
$role = $iamService->getRole("AWSGlueServiceRole-DocExample");
$databaseName = "doc-example-database-$uniqid";
$path = 's3://crawler-public-us-east-1/flight/2016/csv';
$glueService->createCrawler($crawlerName, $role['Role']['Arn'], $databaseName, $path);
$glueService->startCrawler($crawlerName);
echo "Waiting for crawler";
do {
$crawler = $glueService->getCrawler($crawlerName);
echo ".";
sleep(10);
} while ($crawler['Crawler']['State'] != "READY");
echo "\n";
$database = $glueService->getDatabase($databaseName);
echo "Found a database named " . $database['Database']['Name'] . "\n";
//Upload job script
$s3client = new S3Client($clientArgs);
$bucketName = "test-glue-bucket-" . $uniqid;
$s3client->createBucket([
'Bucket' => $bucketName,
'CreateBucketConfiguration' => ['LocationConstraint' => 'us-west-2'],
]);
$s3client->putObject([
'Bucket' => $bucketName,
'Key' => 'run_job.py',
'SourceFile' => __DIR__ . '/flight_etl_job_script.py'
]);
$s3client->putObject([
'Bucket' => $bucketName,
'Key' => 'setup_scenario_getting_started.yaml',
'SourceFile' => __DIR__ . '/setup_scenario_getting_started.yaml'
]);
$tables = $glueService->getTables($databaseName);
$jobName = 'test-job-' . $uniqid;
$scriptLocation = "s3://$bucketName/run_job.py";
$job = $glueService->createJob($jobName, $role['Role']['Arn'], $scriptLocation);
$outputBucketUrl = "s3://$bucketName";
$runId = $glueService->startJobRun($jobName, $databaseName, $tables, $outputBucketUrl)['JobRunId'];
echo "waiting for job";
do {
$jobRun = $glueService->getJobRun($jobName, $runId);
echo ".";
sleep(10);
} while (!array_intersect([$jobRun['JobRun']['JobRunState']], ['SUCCEEDED', 'STOPPED', 'FAILED', 'TIMEOUT']));
echo "\n";
$jobRuns = $glueService->getJobRuns($jobName);
$objects = $s3client->listObjects([
'Bucket' => $bucketName,
])['Contents'];
foreach ($objects as $object) {
echo $object['Key'] . "\n";
}
echo "Downloading " . $objects[1]['Key'] . "\n";
/** @var Stream $downloadObject */
$downloadObject = $s3client->getObject([
'Bucket' => $bucketName,
'Key' => $objects[1]['Key'],
])['Body']->getContents();
echo "Here is the first 1000 characters in the object.";
echo substr($downloadObject, 0, 1000);
$jobs = $glueService->listJobs();
echo "Current jobs:\n";
foreach ($jobs['JobNames'] as $jobsName) {
echo "{$jobsName}\n";
}
echo "Delete the job.\n";
$glueClient->deleteJob([
'JobName' => $job['Name'],
]);
echo "Delete the tables.\n";
foreach ($tables['TableList'] as $table) {
$glueService->deleteTable($table['Name'], $databaseName);
}
echo "Delete the databases.\n";
$glueClient->deleteDatabase([
'Name' => $databaseName,
]);
echo "Delete the crawler.\n";
$glueClient->deleteCrawler([
'Name' => $crawlerName,
]);
$deleteObjects = $s3client->listObjectsV2([
'Bucket' => $bucketName,
]);
echo "Delete all objects in the bucket.\n";
$deleteObjects = $s3client->deleteObjects([
'Bucket' => $bucketName,
'Delete' => [
'Objects' => $deleteObjects['Contents'],
]
]);
echo "Delete the bucket.\n";
$s3client->deleteBucket(['Bucket' => $bucketName]);
echo "This job was brought to you by the number $uniqid\n";
}
}
namespace Glue;
use Aws\Glue\GlueClient;
use Aws\Result;
use function PHPUnit\Framework\isEmpty;
class GlueService extends \AwsUtilities\AWSServiceClass
{
protected GlueClient $glueClient;
public function __construct($glueClient)
{
$this->glueClient = $glueClient;
}
public function getCrawler($crawlerName)
{
return $this->customWaiter(function () use ($crawlerName) {
return $this->glueClient->getCrawler([
'Name' => $crawlerName,
]);
});
}
public function createCrawler($crawlerName, $role, $databaseName, $path): Result
{
return $this->customWaiter(function () use ($crawlerName, $role, $databaseName, $path) {
return $this->glueClient->createCrawler([
'Name' => $crawlerName,
'Role' => $role,
'DatabaseName' => $databaseName,
'Targets' => [
'S3Targets' =>
[[
'Path' => $path,
]]
],
]);
});
}
public function startCrawler($crawlerName): Result
{
return $this->glueClient->startCrawler([
'Name' => $crawlerName,
]);
}
public function getDatabase(string $databaseName): Result
{
return $this->customWaiter(function () use ($databaseName) {
return $this->glueClient->getDatabase([
'Name' => $databaseName,
]);
});
}
public function getTables($databaseName): Result
{
return $this->glueClient->getTables([
'DatabaseName' => $databaseName,
]);
}
public function createJob($jobName, $role, $scriptLocation, $pythonVersion = '3', $glueVersion = '3.0'): Result
{
return $this->glueClient->createJob([
'Name' => $jobName,
'Role' => $role,
'Command' => [
'Name' => 'glueetl',
'ScriptLocation' => $scriptLocation,
'PythonVersion' => $pythonVersion,
],
'GlueVersion' => $glueVersion,
]);
}
public function startJobRun($jobName, $databaseName, $tables, $outputBucketUrl): Result
{
return $this->glueClient->startJobRun([
'JobName' => $jobName,
'Arguments' => [
'input_database' => $databaseName,
'input_table' => $tables['TableList'][0]['Name'],
'output_bucket_url' => $outputBucketUrl,
'--input_database' => $databaseName,
'--input_table' => $tables['TableList'][0]['Name'],
'--output_bucket_url' => $outputBucketUrl,
],
]);
}
public function listJobs($maxResults = null, $nextToken = null, $tags = []): Result
{
$arguments = [];
if ($maxResults) {
$arguments['MaxResults'] = $maxResults;
}
if ($nextToken) {
$arguments['NextToken'] = $nextToken;
}
if (!empty($tags)) {
$arguments['Tags'] = $tags;
}
return $this->glueClient->listJobs($arguments);
}
public function getJobRuns($jobName, $maxResults = 0, $nextToken = ''): Result
{
$arguments = ['JobName' => $jobName];
if ($maxResults) {
$arguments['MaxResults'] = $maxResults;
}
if ($nextToken) {
$arguments['NextToken'] = $nextToken;
}
return $this->glueClient->getJobRuns($arguments);
}
public function getJobRun($jobName, $runId, $predecessorsIncluded = false): Result
{
return $this->glueClient->getJobRun([
'JobName' => $jobName,
'RunId' => $runId,
'PredecessorsIncluded' => $predecessorsIncluded,
]);
}
public function deleteJob($jobName)
{
return $this->glueClient->deleteJob([
'JobName' => $jobName,
]);
}
public function deleteTable($tableName, $databaseName)
{
return $this->glueClient->deleteTable([
'DatabaseName' => $databaseName,
'Name' => $tableName,
]);
}
public function deleteDatabase($databaseName)
{
return $this->glueClient->deleteDatabase([
'Name' => $databaseName,
]);
}
public function deleteCrawler($crawlerName)
{
return $this->glueClient->deleteCrawler([
'Name' => $crawlerName,
]);
}
}
```
+ Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per PHP *.
+ [CreateCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/CreateCrawler)
+ [CreateJob](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/CreateJob)
+ [DeleteCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteCrawler)
+ [DeleteDatabase](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteDatabase)
+ [DeleteJob](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteJob)
+ [DeleteTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteTable)
+ [GetCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetCrawler)
+ [GetDatabase](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetDatabase)
+ [GetDatabases](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetDatabases)
+ [GetJob](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetJob)
+ [GetJobRun](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetJobRun)
+ [GetJobRuns](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetJobRuns)
+ [GetTables](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetTables)
+ [ListJobs](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/ListJobs)
+ [StartCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/StartCrawler)
+ [StartJobRun](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/StartJobRun)
## Azioni
### `CreateCrawler`
Il seguente esempio di codice mostra come usare`CreateCrawler`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
$crawlerName = "example-crawler-test-" . $uniqid;
$role = $iamService->getRole("AWSGlueServiceRole-DocExample");
$path = 's3://crawler-public-us-east-1/flight/2016/csv';
$glueService->createCrawler($crawlerName, $role['Role']['Arn'], $databaseName, $path);
public function createCrawler($crawlerName, $role, $databaseName, $path): Result
{
return $this->customWaiter(function () use ($crawlerName, $role, $databaseName, $path) {
return $this->glueClient->createCrawler([
'Name' => $crawlerName,
'Role' => $role,
'DatabaseName' => $databaseName,
'Targets' => [
'S3Targets' =>
[[
'Path' => $path,
]]
],
]);
});
}
```
+ Per i dettagli sull'API, [CreateCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/CreateCrawler)consulta *AWS SDK per PHP API Reference*.
### `CreateJob`
Il seguente esempio di codice mostra come utilizzare`CreateJob`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
$role = $iamService->getRole("AWSGlueServiceRole-DocExample");
$jobName = 'test-job-' . $uniqid;
$scriptLocation = "s3://$bucketName/run_job.py";
$job = $glueService->createJob($jobName, $role['Role']['Arn'], $scriptLocation);
public function createJob($jobName, $role, $scriptLocation, $pythonVersion = '3', $glueVersion = '3.0'): Result
{
return $this->glueClient->createJob([
'Name' => $jobName,
'Role' => $role,
'Command' => [
'Name' => 'glueetl',
'ScriptLocation' => $scriptLocation,
'PythonVersion' => $pythonVersion,
],
'GlueVersion' => $glueVersion,
]);
}
```
+ Per i dettagli sull'API, [CreateJob](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/CreateJob)consulta *AWS SDK per PHP API Reference*.
### `DeleteCrawler`
Il seguente esempio di codice mostra come utilizzare`DeleteCrawler`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
echo "Delete the crawler.\n";
$glueClient->deleteCrawler([
'Name' => $crawlerName,
]);
public function deleteCrawler($crawlerName)
{
return $this->glueClient->deleteCrawler([
'Name' => $crawlerName,
]);
}
```
+ Per i dettagli sull'API, [DeleteCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteCrawler)consulta *AWS SDK per PHP API Reference*.
### `DeleteDatabase`
Il seguente esempio di codice mostra come utilizzare`DeleteDatabase`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
echo "Delete the databases.\n";
$glueClient->deleteDatabase([
'Name' => $databaseName,
]);
public function deleteDatabase($databaseName)
{
return $this->glueClient->deleteDatabase([
'Name' => $databaseName,
]);
}
```
+ Per i dettagli sull'API, [DeleteDatabase](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteDatabase)consulta *AWS SDK per PHP API Reference*.
### `DeleteJob`
Il seguente esempio di codice mostra come utilizzare`DeleteJob`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
echo "Delete the job.\n";
$glueClient->deleteJob([
'JobName' => $job['Name'],
]);
public function deleteJob($jobName)
{
return $this->glueClient->deleteJob([
'JobName' => $jobName,
]);
}
```
+ Per i dettagli sull'API, [DeleteJob](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteJob)consulta *AWS SDK per PHP API Reference*.
### `DeleteTable`
Il seguente esempio di codice mostra come utilizzare`DeleteTable`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
echo "Delete the tables.\n";
foreach ($tables['TableList'] as $table) {
$glueService->deleteTable($table['Name'], $databaseName);
}
public function deleteTable($tableName, $databaseName)
{
return $this->glueClient->deleteTable([
'DatabaseName' => $databaseName,
'Name' => $tableName,
]);
}
```
+ Per i dettagli sull'API, [DeleteTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteTable)consulta *AWS SDK per PHP API Reference*.
### `GetCrawler`
Il seguente esempio di codice mostra come utilizzare`GetCrawler`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
echo "Waiting for crawler";
do {
$crawler = $glueService->getCrawler($crawlerName);
echo ".";
sleep(10);
} while ($crawler['Crawler']['State'] != "READY");
echo "\n";
public function getCrawler($crawlerName)
{
return $this->customWaiter(function () use ($crawlerName) {
return $this->glueClient->getCrawler([
'Name' => $crawlerName,
]);
});
}
```
+ Per i dettagli sull'API, [GetCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetCrawler)consulta *AWS SDK per PHP API Reference*.
### `GetDatabase`
Il seguente esempio di codice mostra come utilizzare`GetDatabase`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
$databaseName = "doc-example-database-$uniqid";
$database = $glueService->getDatabase($databaseName);
echo "Found a database named " . $database['Database']['Name'] . "\n";
public function getDatabase(string $databaseName): Result
{
return $this->customWaiter(function () use ($databaseName) {
return $this->glueClient->getDatabase([
'Name' => $databaseName,
]);
});
}
```
+ Per i dettagli sull'API, [GetDatabase](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetDatabase)consulta *AWS SDK per PHP API Reference*.
### `GetJobRun`
Il seguente esempio di codice mostra come utilizzare`GetJobRun`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
$jobName = 'test-job-' . $uniqid;
$outputBucketUrl = "s3://$bucketName";
$runId = $glueService->startJobRun($jobName, $databaseName, $tables, $outputBucketUrl)['JobRunId'];
echo "waiting for job";
do {
$jobRun = $glueService->getJobRun($jobName, $runId);
echo ".";
sleep(10);
} while (!array_intersect([$jobRun['JobRun']['JobRunState']], ['SUCCEEDED', 'STOPPED', 'FAILED', 'TIMEOUT']));
echo "\n";
public function getJobRun($jobName, $runId, $predecessorsIncluded = false): Result
{
return $this->glueClient->getJobRun([
'JobName' => $jobName,
'RunId' => $runId,
'PredecessorsIncluded' => $predecessorsIncluded,
]);
}
```
+ Per i dettagli sull'API, [GetJobRun](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetJobRun)consulta *AWS SDK per PHP API Reference*.
### `GetJobRuns`
Il seguente esempio di codice mostra come utilizzare`GetJobRuns`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
$jobName = 'test-job-' . $uniqid;
$jobRuns = $glueService->getJobRuns($jobName);
public function getJobRuns($jobName, $maxResults = 0, $nextToken = ''): Result
{
$arguments = ['JobName' => $jobName];
if ($maxResults) {
$arguments['MaxResults'] = $maxResults;
}
if ($nextToken) {
$arguments['NextToken'] = $nextToken;
}
return $this->glueClient->getJobRuns($arguments);
}
```
+ Per i dettagli sull'API, [GetJobRuns](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetJobRuns)consulta *AWS SDK per PHP API Reference*.
### `GetTables`
Il seguente esempio di codice mostra come utilizzare`GetTables`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
$databaseName = "doc-example-database-$uniqid";
$tables = $glueService->getTables($databaseName);
public function getTables($databaseName): Result
{
return $this->glueClient->getTables([
'DatabaseName' => $databaseName,
]);
}
```
+ Per i dettagli sull'API, [GetTables](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetTables)consulta *AWS SDK per PHP API Reference*.
### `ListJobs`
Il seguente esempio di codice mostra come utilizzare`ListJobs`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
$jobs = $glueService->listJobs();
echo "Current jobs:\n";
foreach ($jobs['JobNames'] as $jobsName) {
echo "{$jobsName}\n";
}
public function listJobs($maxResults = null, $nextToken = null, $tags = []): Result
{
$arguments = [];
if ($maxResults) {
$arguments['MaxResults'] = $maxResults;
}
if ($nextToken) {
$arguments['NextToken'] = $nextToken;
}
if (!empty($tags)) {
$arguments['Tags'] = $tags;
}
return $this->glueClient->listJobs($arguments);
}
```
+ Per i dettagli sull'API, [ListJobs](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/ListJobs)consulta *AWS SDK per PHP API Reference*.
### `StartCrawler`
Il seguente esempio di codice mostra come utilizzare`StartCrawler`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
$crawlerName = "example-crawler-test-" . $uniqid;
$databaseName = "doc-example-database-$uniqid";
$glueService->startCrawler($crawlerName);
public function startCrawler($crawlerName): Result
{
return $this->glueClient->startCrawler([
'Name' => $crawlerName,
]);
}
```
+ Per i dettagli sull'API, [StartCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/StartCrawler)consulta *AWS SDK per PHP API Reference*.
### `StartJobRun`
Il seguente esempio di codice mostra come utilizzare`StartJobRun`.
**SDK per PHP**
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/php/example_code/glue#code-examples).
```
$jobName = 'test-job-' . $uniqid;
$databaseName = "doc-example-database-$uniqid";
$tables = $glueService->getTables($databaseName);
$outputBucketUrl = "s3://$bucketName";
$runId = $glueService->startJobRun($jobName, $databaseName, $tables, $outputBucketUrl)['JobRunId'];
public function startJobRun($jobName, $databaseName, $tables, $outputBucketUrl): Result
{
return $this->glueClient->startJobRun([
'JobName' => $jobName,
'Arguments' => [
'input_database' => $databaseName,
'input_table' => $tables['TableList'][0]['Name'],
'output_bucket_url' => $outputBucketUrl,
'--input_database' => $databaseName,
'--input_table' => $tables['TableList'][0]['Name'],
'--output_bucket_url' => $outputBucketUrl,
],
]);
}
```
+ Per i dettagli sull'API, [StartJobRun](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/StartJobRun)consulta *AWS SDK per PHP API Reference*.
# Esempi per IAM con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP with IAM.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
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.
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**
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come creare un utente e assumere un ruolo.
**avvertimento**
Per evitare rischi per la sicurezza, non utilizzare gli utenti IAM per l’autenticazione quando sviluppi software creato ad hoc o lavori con dati reali. Utilizza invece la federazione con un provider di identità come [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
+ Crea un utente che non disponga di autorizzazioni.
+ Crea un ruolo che conceda l’autorizzazione per elencare i bucket Amazon S3 per l’account.
+ Aggiungi una policy per consentire all’utente di assumere il ruolo.
+ Assumi il ruolo ed elenca i bucket S3 utilizzando le credenziali temporanee, quindi ripulisci le risorse.
**SDK per PHP**
C'è di più 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/php/example_code/iam#code-examples).
```
namespace Iam\Basics;
require 'vendor/autoload.php';
use Aws\Credentials\Credentials;
use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;
use Iam\IAMService;
echo("\n");
echo("--------------------------------------\n");
print("Welcome to the IAM getting started demo using PHP!\n");
echo("--------------------------------------\n");
$uuid = uniqid();
$service = new IAMService();
$user = $service->createUser("iam_demo_user_$uuid");
echo "Created user with the arn: {$user['Arn']}\n";
$key = $service->createAccessKey($user['UserName']);
$assumeRolePolicyDocument = "{
\"Version\": \"2012-10-17\",
\"Statement\": [{
\"Effect\": \"Allow\",
\"Principal\": {\"AWS\": \"{$user['Arn']}\"},
\"Action\": \"sts:AssumeRole\"
}]
}";
$assumeRoleRole = $service->createRole("iam_demo_role_$uuid", $assumeRolePolicyDocument);
echo "Created role: {$assumeRoleRole['RoleName']}\n";
$listAllBucketsPolicyDocument = "{
\"Version\": \"2012-10-17\",
\"Statement\": [{
\"Effect\": \"Allow\",
\"Action\": \"s3:ListAllMyBuckets\",
\"Resource\": \"arn:aws:s3:::*\"}]
}";
$listAllBucketsPolicy = $service->createPolicy("iam_demo_policy_$uuid", $listAllBucketsPolicyDocument);
echo "Created policy: {$listAllBucketsPolicy['PolicyName']}\n";
$service->attachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']);
$inlinePolicyDocument = "{
\"Version\": \"2012-10-17\",
\"Statement\": [{
\"Effect\": \"Allow\",
\"Action\": \"sts:AssumeRole\",
\"Resource\": \"{$assumeRoleRole['Arn']}\"}]
}";
$inlinePolicy = $service->createUserPolicy("iam_demo_inline_policy_$uuid", $inlinePolicyDocument, $user['UserName']);
//First, fail to list the buckets with the user
$credentials = new Credentials($key['AccessKeyId'], $key['SecretAccessKey']);
$s3Client = new S3Client(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $credentials]);
try {
$s3Client->listBuckets([
]);
echo "this should not run";
} catch (S3Exception $exception) {
echo "successfully failed!\n";
}
$stsClient = new StsClient(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $credentials]);
sleep(10);
$assumedRole = $stsClient->assumeRole([
'RoleArn' => $assumeRoleRole['Arn'],
'RoleSessionName' => "DemoAssumeRoleSession_$uuid",
]);
$assumedCredentials = [
'key' => $assumedRole['Credentials']['AccessKeyId'],
'secret' => $assumedRole['Credentials']['SecretAccessKey'],
'token' => $assumedRole['Credentials']['SessionToken'],
];
$s3Client = new S3Client(['region' => 'us-west-2', 'version' => 'latest', 'credentials' => $assumedCredentials]);
try {
$s3Client->listBuckets([]);
echo "this should now run!\n";
} catch (S3Exception $exception) {
echo "this should now not fail\n";
}
$service->detachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']);
$deletePolicy = $service->deletePolicy($listAllBucketsPolicy['Arn']);
echo "Delete policy: {$listAllBucketsPolicy['PolicyName']}\n";
$deletedRole = $service->deleteRole($assumeRoleRole['Arn']);
echo "Deleted role: {$assumeRoleRole['RoleName']}\n";
$deletedKey = $service->deleteAccessKey($key['AccessKeyId'], $user['UserName']);
$deletedUser = $service->deleteUser($user['UserName']);
echo "Delete user: {$user['UserName']}\n";
```
+ Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per PHP *.
+ [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/AttachRolePolicy)
+ [CreateAccessKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateAccessKey)
+ [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreatePolicy)
+ [CreateRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateRole)
+ [CreateUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateUser)
+ [DeleteAccessKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteAccessKey)
+ [DeletePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeletePolicy)
+ [DeleteRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteRole)
+ [DeleteUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteUser)
+ [DeleteUserPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DeleteUserPolicy)
+ [DetachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/DetachRolePolicy)
+ [PutUserPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/PutUserPolicy)
## Azioni
### `AttachRolePolicy`
Il seguente esempio di codice mostra come usare`AttachRolePolicy`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
$assumeRolePolicyDocument = "{
\"Version\": \"2012-10-17\",
\"Statement\": [{
\"Effect\": \"Allow\",
\"Principal\": {\"AWS\": \"{$user['Arn']}\"},
\"Action\": \"sts:AssumeRole\"
}]
}";
$assumeRoleRole = $service->createRole("iam_demo_role_$uuid", $assumeRolePolicyDocument);
echo "Created role: {$assumeRoleRole['RoleName']}\n";
$listAllBucketsPolicyDocument = "{
\"Version\": \"2012-10-17\",
\"Statement\": [{
\"Effect\": \"Allow\",
\"Action\": \"s3:ListAllMyBuckets\",
\"Resource\": \"arn:aws:s3:::*\"}]
}";
$listAllBucketsPolicy = $service->createPolicy("iam_demo_policy_$uuid", $listAllBucketsPolicyDocument);
echo "Created policy: {$listAllBucketsPolicy['PolicyName']}\n";
$service->attachRolePolicy($assumeRoleRole['RoleName'], $listAllBucketsPolicy['Arn']);
public function attachRolePolicy($roleName, $policyArn)
{
return $this->customWaiter(function () use ($roleName, $policyArn) {
$this->iamClient->attachRolePolicy([
'PolicyArn' => $policyArn,
'RoleName' => $roleName,
]);
});
}
```
+ Per i dettagli sull'API, [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/AttachRolePolicy)consulta *AWS SDK per PHP API Reference*.
### `CreatePolicy`
Il seguente esempio di codice mostra come utilizzare`CreatePolicy`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
$listAllBucketsPolicyDocument = "{
\"Version\": \"2012-10-17\",
\"Statement\": [{
\"Effect\": \"Allow\",
\"Action\": \"s3:ListAllMyBuckets\",
\"Resource\": \"arn:aws:s3:::*\"}]
}";
$listAllBucketsPolicy = $service->createPolicy("iam_demo_policy_$uuid", $listAllBucketsPolicyDocument);
echo "Created policy: {$listAllBucketsPolicy['PolicyName']}\n";
/**
* @param string $policyName
* @param string $policyDocument
* @return array
*/
public function createPolicy(string $policyName, string $policyDocument)
{
$result = $this->customWaiter(function () use ($policyName, $policyDocument) {
return $this->iamClient->createPolicy([
'PolicyName' => $policyName,
'PolicyDocument' => $policyDocument,
]);
});
return $result['Policy'];
}
```
+ Per i dettagli sull'API, [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreatePolicy)consulta *AWS SDK per PHP API Reference*.
### `CreateRole`
Il seguente esempio di codice mostra come utilizzare`CreateRole`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
$assumeRolePolicyDocument = "{
\"Version\": \"2012-10-17\",
\"Statement\": [{
\"Effect\": \"Allow\",
\"Principal\": {\"AWS\": \"{$user['Arn']}\"},
\"Action\": \"sts:AssumeRole\"
}]
}";
$assumeRoleRole = $service->createRole("iam_demo_role_$uuid", $assumeRolePolicyDocument);
echo "Created role: {$assumeRoleRole['RoleName']}\n";
/**
* @param string $roleName
* @param string $rolePolicyDocument
* @return array
* @throws AwsException
*/
public function createRole(string $roleName, string $rolePolicyDocument)
{
$result = $this->customWaiter(function () use ($roleName, $rolePolicyDocument) {
return $this->iamClient->createRole([
'AssumeRolePolicyDocument' => $rolePolicyDocument,
'RoleName' => $roleName,
]);
});
return $result['Role'];
}
```
+ Per i dettagli sull'API, [CreateRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateRole)consulta *AWS SDK per PHP API Reference*.
### `CreateServiceLinkedRole`
Il seguente esempio di codice mostra come utilizzare`CreateServiceLinkedRole`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
public function createServiceLinkedRole($awsServiceName, $customSuffix = "", $description = "")
{
$createServiceLinkedRoleArguments = ['AWSServiceName' => $awsServiceName];
if ($customSuffix) {
$createServiceLinkedRoleArguments['CustomSuffix'] = $customSuffix;
}
if ($description) {
$createServiceLinkedRoleArguments['Description'] = $description;
}
return $this->iamClient->createServiceLinkedRole($createServiceLinkedRoleArguments);
}
```
+ Per i dettagli sull'API, [CreateServiceLinkedRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateServiceLinkedRole)consulta *AWS SDK per PHP API Reference*.
### `CreateUser`
Il seguente esempio di codice mostra come utilizzare`CreateUser`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
$user = $service->createUser("iam_demo_user_$uuid");
echo "Created user with the arn: {$user['Arn']}\n";
/**
* @param string $name
* @return array
* @throws AwsException
*/
public function createUser(string $name): array
{
$result = $this->iamClient->createUser([
'UserName' => $name,
]);
return $result['User'];
}
```
+ Per i dettagli sull'API, [CreateUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateUser)consulta *AWS SDK per PHP API Reference*.
### `GetAccountPasswordPolicy`
Il seguente esempio di codice mostra come utilizzare`GetAccountPasswordPolicy`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
public function getAccountPasswordPolicy()
{
return $this->iamClient->getAccountPasswordPolicy();
}
```
+ Per i dettagli sull'API, [GetAccountPasswordPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/GetAccountPasswordPolicy)consulta *AWS SDK per PHP API Reference*.
### `GetPolicy`
Il seguente esempio di codice mostra come utilizzare`GetPolicy`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
public function getPolicy($policyArn)
{
return $this->customWaiter(function () use ($policyArn) {
return $this->iamClient->getPolicy(['PolicyArn' => $policyArn]);
});
}
```
+ Per i dettagli sull'API, [GetPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/GetPolicy)consulta *AWS SDK per PHP API Reference*.
### `GetRole`
Il seguente esempio di codice mostra come utilizzare`GetRole`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
public function getRole($roleName)
{
return $this->customWaiter(function () use ($roleName) {
return $this->iamClient->getRole(['RoleName' => $roleName]);
});
}
```
+ Per i dettagli sull'API, [GetRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/GetRole)consulta *AWS SDK per PHP API Reference*.
### `ListAttachedRolePolicies`
Il seguente esempio di codice mostra come utilizzare`ListAttachedRolePolicies`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
public function listAttachedRolePolicies($roleName, $pathPrefix = "", $marker = "", $maxItems = 0)
{
$listAttachRolePoliciesArguments = ['RoleName' => $roleName];
if ($pathPrefix) {
$listAttachRolePoliciesArguments['PathPrefix'] = $pathPrefix;
}
if ($marker) {
$listAttachRolePoliciesArguments['Marker'] = $marker;
}
if ($maxItems) {
$listAttachRolePoliciesArguments['MaxItems'] = $maxItems;
}
return $this->iamClient->listAttachedRolePolicies($listAttachRolePoliciesArguments);
}
```
+ Per i dettagli sull'API, [ListAttachedRolePolicies](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListAttachedRolePolicies)consulta *AWS SDK per PHP API Reference*.
### `ListGroups`
Il seguente esempio di codice mostra come utilizzare`ListGroups`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
public function listGroups($pathPrefix = "", $marker = "", $maxItems = 0)
{
$listGroupsArguments = [];
if ($pathPrefix) {
$listGroupsArguments["PathPrefix"] = $pathPrefix;
}
if ($marker) {
$listGroupsArguments["Marker"] = $marker;
}
if ($maxItems) {
$listGroupsArguments["MaxItems"] = $maxItems;
}
return $this->iamClient->listGroups($listGroupsArguments);
}
```
+ Per i dettagli sull'API, [ListGroups](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListGroups)consulta *AWS SDK per PHP API Reference*.
### `ListPolicies`
Il seguente esempio di codice mostra come utilizzare`ListPolicies`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
public function listPolicies($pathPrefix = "", $marker = "", $maxItems = 0)
{
$listPoliciesArguments = [];
if ($pathPrefix) {
$listPoliciesArguments["PathPrefix"] = $pathPrefix;
}
if ($marker) {
$listPoliciesArguments["Marker"] = $marker;
}
if ($maxItems) {
$listPoliciesArguments["MaxItems"] = $maxItems;
}
return $this->iamClient->listPolicies($listPoliciesArguments);
}
```
+ Per i dettagli sull'API, [ListPolicies](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListPolicies)consulta *AWS SDK per PHP API Reference*.
### `ListRolePolicies`
Il seguente esempio di codice mostra come utilizzare`ListRolePolicies`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
public function listRolePolicies($roleName, $marker = "", $maxItems = 0)
{
$listRolePoliciesArguments = ['RoleName' => $roleName];
if ($marker) {
$listRolePoliciesArguments['Marker'] = $marker;
}
if ($maxItems) {
$listRolePoliciesArguments['MaxItems'] = $maxItems;
}
return $this->customWaiter(function () use ($listRolePoliciesArguments) {
return $this->iamClient->listRolePolicies($listRolePoliciesArguments);
});
}
```
+ Per i dettagli sull'API, [ListRolePolicies](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListRolePolicies)consulta *AWS SDK per PHP API Reference*.
### `ListRoles`
Il seguente esempio di codice mostra come utilizzare`ListRoles`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
/**
* @param string $pathPrefix
* @param string $marker
* @param int $maxItems
* @return Result
* $roles = $service->listRoles();
*/
public function listRoles($pathPrefix = "", $marker = "", $maxItems = 0)
{
$listRolesArguments = [];
if ($pathPrefix) {
$listRolesArguments["PathPrefix"] = $pathPrefix;
}
if ($marker) {
$listRolesArguments["Marker"] = $marker;
}
if ($maxItems) {
$listRolesArguments["MaxItems"] = $maxItems;
}
return $this->iamClient->listRoles($listRolesArguments);
}
```
+ Per i dettagli sull'API, [ListRoles](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListRoles)consulta *AWS SDK per PHP API Reference*.
### `ListSAMLProviders`
Il seguente esempio di codice mostra come utilizzare`ListSAMLProviders`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
public function listSAMLProviders()
{
return $this->iamClient->listSAMLProviders();
}
```
+ Per i dettagli sull'API, consulta [List SAMLProviders](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListSAMLProviders) in *AWS SDK per PHP API Reference*.
### `ListUsers`
Il seguente esempio di codice mostra come utilizzare`ListUsers`.
**SDK per PHP**
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/php/example_code/iam#code-examples).
```
$uuid = uniqid();
$service = new IAMService();
public function listUsers($pathPrefix = "", $marker = "", $maxItems = 0)
{
$listUsersArguments = [];
if ($pathPrefix) {
$listUsersArguments["PathPrefix"] = $pathPrefix;
}
if ($marker) {
$listUsersArguments["Marker"] = $marker;
}
if ($maxItems) {
$listUsersArguments["MaxItems"] = $maxItems;
}
return $this->iamClient->listUsers($listUsersArguments);
}
```
+ Per i dettagli sull'API, [ListUsers](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListUsers)consulta *AWS SDK per PHP API Reference*.
# Esempi per Kinesis con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP con Kinesis.
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**
+ [Esempi serverless](#serverless_examples)
## Esempi serverless
### Invocare una funzione Lambda da un trigger Kinesis
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di record da un flusso Kinesis. La funzione recupera il payload Kinesis, lo decodifica da Base64 e registra il contenuto del record.
**SDK per PHP**
C'è di più su. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda).
Utilizzo di un evento Kinesis con Lambda tramite PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
logger = $logger;
}
/**
* @throws JsonException
* @throws \Bref\Event\InvalidLambdaEvent
*/
public function handleKinesis(KinesisEvent $event, Context $context): void
{
$this->logger->info("Processing records");
$records = $event->getRecords();
foreach ($records as $record) {
$data = $record->getData();
$this->logger->info(json_encode($data));
// TODO: Do interesting work based on the new data
// Any exception thrown will be logged and the invocation will be marked as failed
}
$totalRecords = count($records);
$this->logger->info("Successfully processed $totalRecords records");
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
### Segnalazione di errori di elementi batch per funzioni Lambda con un trigger Kinesis
L’esempio di codice seguente mostra come implementare una risposta batch parziale per funzioni Lambda che ricevono eventi da un flusso Kinesis. La funzione riporta gli errori degli elementi batch nella risposta, segnalando a Lambda di riprovare tali messaggi in un secondo momento.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda-with-batch-item-handling).
Segnalazione di errori di elementi batch di Kinesis con Lambda tramite PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
logger = $logger;
}
/**
* @throws JsonException
* @throws \Bref\Event\InvalidLambdaEvent
*/
public function handle(mixed $event, Context $context): array
{
$kinesisEvent = new KinesisEvent($event);
$this->logger->info("Processing records");
$records = $kinesisEvent->getRecords();
$failedRecords = [];
foreach ($records as $record) {
try {
$data = $record->getData();
$this->logger->info(json_encode($data));
// TODO: Do interesting work based on the new data
} catch (Exception $e) {
$this->logger->error($e->getMessage());
// failed processing the record
$failedRecords[] = $record->getSequenceNumber();
}
}
$totalRecords = count($records);
$this->logger->info("Successfully processed $totalRecords records");
// change format for the response
$failures = array_map(
fn(string $sequenceNumber) => ['itemIdentifier' => $sequenceNumber],
$failedRecords
);
return [
'batchItemFailures' => $failures
];
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
# AWS KMS esempi che utilizzano SDK for PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP with AWS KMS.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
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.
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**
+ [Nozioni di base](#get_started)
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
## Nozioni di base
### Salve AWS KMS
L’esempio di codice seguente mostra come iniziare a utilizzare AWS Key Management Service.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
include "vendor/autoload.php";
use Aws\Kms\KmsClient;
echo "This file shows how to connect to the KmsClient, uses a paginator to get the keys for the account, and lists the KeyIds for up to 10 keys.\n";
$client = new KmsClient([]);
$pageLength = 10; // Change this value to change the number of records shown, or to break up the result into pages.
$keys = [];
$keysPaginator = $client->getPaginator("ListKeys", ['Limit' => $pageLength]);
foreach($keysPaginator as $page){
foreach($page['Keys'] as $index => $key){
echo "The $index index Key's ID is: {$key['KeyId']}\n";
}
echo "End of page one of results. Alter the \$pageLength variable to see more results.\n";
break;
}
```
+ Per i dettagli sull'API, [ListKeys](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListKeys)consulta *AWS SDK per PHP API Reference*.
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come:
+ Creare una chiave KMS.
+ Elencare le chiavi KMS dell’account e ottenere i relativi dettagli.
+ Abilitare e disabilitare le chiavi KMS.
+ Generare una chiave dati simmetrica che può essere utilizzata per la crittografia lato client.
+ Generare una chiave asimmetrica per firmare digitalmente i dati.
+ Taggare le chiavi.
+ Eliminare le chiavi KMS.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
echo "\n";
echo "--------------------------------------\n";
echo <<pressEnter();
$this->kmsClient = new KmsClient([]);
// Initialize the KmsService class with the client. This allows you to override any defaults in the client before giving it to the service class.
$this->kmsService = new KmsService($this->kmsClient);
// 1. Create a symmetric KMS key.
echo "\n";
echo "1. Create a symmetric KMS key.\n";
echo "First, we will create a symmetric KMS key that is used to encrypt and decrypt data by invoking createKey().\n";
$this->pressEnter();
$key = $this->kmsService->createKey();
$this->resources['symmetricKey'] = $key['KeyId'];
echo "Created a customer key with ARN {$key['Arn']}.\n";
$this->pressEnter();
// 2. Enable a KMS key.
echo "\n";
echo "2. Enable a KMS key.\n";
echo "By default when you create an AWS key, it is enabled. The code checks to
determine if the key is enabled. If it is not enabled, the code enables it.\n";
$this->pressEnter();
$keyInfo = $this->kmsService->describeKey($key['KeyId']);
if(!$keyInfo['Enabled']){
echo "The key was not enabled, so we will enable it.\n";
$this->pressEnter();
$this->kmsService->enableKey($key['KeyId']);
echo "The key was successfully enabled.\n";
}else{
echo "The key was already enabled, so there was no need to enable it.\n";
}
$this->pressEnter();
// 3. Encrypt data using the symmetric KMS key.
echo "\n";
echo "3. Encrypt data using the symmetric KMS key.\n";
echo "One of the main uses of symmetric keys is to encrypt and decrypt data.\n";
echo "Next, we'll encrypt the string 'Hello, AWS KMS!' with the SYMMETRIC_DEFAULT encryption algorithm.\n";
$this->pressEnter();
$text = "Hello, AWS KMS!";
$encryption = $this->kmsService->encrypt($key['KeyId'], $text);
echo "The plaintext data was successfully encrypted with the algorithm: {$encryption['EncryptionAlgorithm']}.\n";
$this->pressEnter();
// 4. Create an alias.
echo "\n";
echo "4. Create an alias.\n";
$aliasInput = testable_readline("Please enter an alias prefixed with \"alias/\" or press enter to use a default value: ");
if($aliasInput == ""){
$aliasInput = "alias/dev-encryption-key";
}
$this->kmsService->createAlias($key['KeyId'], $aliasInput);
$this->resources['alias'] = $aliasInput;
echo "The alias \"$aliasInput\" was successfully created.\n";
$this->pressEnter();
// 5. List all of your aliases.
$aliasPageSize = 10;
echo "\n";
echo "5. List all of your aliases, up to $aliasPageSize.\n";
$this->pressEnter();
$aliasPaginator = $this->kmsService->listAliases();
foreach($aliasPaginator as $pages){
foreach($pages['Aliases'] as $alias){
echo $alias['AliasName'] . "\n";
}
break;
}
$this->pressEnter();
// 6. Enable automatic rotation of the KMS key.
echo "\n";
echo "6. Enable automatic rotation of the KMS key.\n";
echo "By default, when the SDK enables automatic rotation of a KMS key,
KMS rotates the key material of the KMS key one year (approximately 365 days) from the enable date and every year
thereafter.";
$this->pressEnter();
$this->kmsService->enableKeyRotation($key['KeyId']);
echo "The key's rotation was successfully set for key: {$key['KeyId']}\n";
$this->pressEnter();
// 7. Create a grant.
echo "7. Create a grant.\n";
echo "\n";
echo "A grant is a policy instrument that allows Amazon Web Services principals to use KMS keys.
It also can allow them to view a KMS key (DescribeKey) and create and manage grants.
When authorizing access to a KMS key, grants are considered along with key policies and IAM policies.\n";
$granteeARN = testable_readline("Please enter the Amazon Resource Name (ARN) of an Amazon Web Services principal. Valid principals include Amazon Web Services accounts, IAM users, IAM roles, federated users, and assumed role users. For help with the ARN syntax for a principal, see IAM ARNs in the Identity and Access Management User Guide. \nTo skip this step, press enter without any other values: ");
if($granteeARN){
$operations = [
"ENCRYPT",
"DECRYPT",
"DESCRIBE_KEY",
];
$grant = $this->kmsService->createGrant($key['KeyId'], $granteeARN, $operations);
echo "The grant Id is: {$grant['GrantId']}\n";
}else{
echo "Steps 7, 8, and 9 will be skipped.\n";
}
$this->pressEnter();
// 8. List grants for the KMS key.
if($granteeARN){
echo "8. List grants for the KMS key.\n\n";
$grantsPaginator = $this->kmsService->listGrants($key['KeyId']);
foreach($grantsPaginator as $page){
foreach($page['Grants'] as $grant){
echo $grant['GrantId'] . "\n";
}
}
}else{
echo "Skipping step 8...\n";
}
$this->pressEnter();
// 9. Revoke the grant.
if($granteeARN) {
echo "\n";
echo "9. Revoke the grant.\n";
$this->pressEnter();
$this->kmsService->revokeGrant($grant['GrantId'], $keyInfo['KeyId']);
echo "{$grant['GrantId']} was successfully revoked!\n";
}else{
echo "Skipping step 9...\n";
}
$this->pressEnter();
// 10. Decrypt the data.
echo "\n";
echo "10. Decrypt the data.\n";
echo "Let's decrypt the data that was encrypted before.\n";
echo "We'll use the same key to decrypt the string that we encrypted earlier in the program.\n";
$this->pressEnter();
$decryption = $this->kmsService->decrypt($keyInfo['KeyId'], $encryption['CiphertextBlob'], $encryption['EncryptionAlgorithm']);
echo "The decrypted text is: {$decryption['Plaintext']}\n";
$this->pressEnter();
// 11. Replace a Key Policy.
echo "\n";
echo "11. Replace a Key Policy.\n";
echo "A key policy is a resource policy for a KMS key. Key policies are the primary way to control access to KMS keys.\n";
echo "Every KMS key must have exactly one key policy. The statements in the key policy determine who has permission to use the KMS key and how they can use it.\n";
echo " You can also use IAM policies and grants to control access to the KMS key, but every KMS key must have a key policy.\n";
echo "We will replace the key's policy with a new one:\n";
$stsClient = new StsClient([]);
$result = $stsClient->getCallerIdentity();
$accountId = $result['Account'];
$keyPolicy = <<< KEYPOLICY
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {"AWS": "arn:aws:iam::$accountId:root"},
"Action": "kms:*",
"Resource": "*"
}]
}
KEYPOLICY;
echo $keyPolicy;
$this->pressEnter();
$this->kmsService->putKeyPolicy($keyInfo['KeyId'], $keyPolicy);
echo "The Key Policy was successfully replaced!\n";
$this->pressEnter();
// 12. Retrieve the key policy.
echo "\n";
echo "12. Retrieve the key policy.\n";
echo "Let's get some information about the new policy and print it to the screen.\n";
$this->pressEnter();
$policyInfo = $this->kmsService->getKeyPolicy($keyInfo['KeyId']);
echo "We got the info! Here is the policy: \n";
echo $policyInfo['Policy'] . "\n";
$this->pressEnter();
// 13. Create an asymmetric KMS key and sign data.
echo "\n";
echo "13. Create an asymmetric KMS key and sign data.\n";
echo "Signing your data with an AWS key can provide several benefits that make it an attractive option for your data signing needs.\n";
echo "By using an AWS KMS key, you can leverage the security controls and compliance features provided by AWS, which can help you meet various regulatory requirements and enhance the overall security posture of your organization.\n";
echo "First we'll create the asymmetric key.\n";
$this->pressEnter();
$keySpec = "RSA_2048";
$keyUsage = "SIGN_VERIFY";
$asymmetricKey = $this->kmsService->createKey($keySpec, $keyUsage);
$this->resources['asymmetricKey'] = $asymmetricKey['KeyId'];
echo "Created the key with ID: {$asymmetricKey['KeyId']}\n";
echo "Next, we'll sign the data.\n";
$this->pressEnter();
$algorithm = "RSASSA_PSS_SHA_256";
$sign = $this->kmsService->sign($asymmetricKey['KeyId'], $text, $algorithm);
$verify = $this->kmsService->verify($asymmetricKey['KeyId'], $text, $sign['Signature'], $algorithm);
echo "Signature verification result: {$sign['signature']}\n";
$this->pressEnter();
// 14. Tag the symmetric KMS key.
echo "\n";
echo "14. Tag the symmetric KMS key.\n";
echo "By using tags, you can improve the overall management, security, and governance of your KMS keys, making it easier to organize, track, and control access to your encrypted data within your AWS environment.\n";
echo "Let's tag our symmetric key as Environment->Production\n";
$this->pressEnter();
$this->kmsService->tagResource($key['KeyId'], [
[
'TagKey' => "Environment",
'TagValue' => "Production",
],
]);
echo "The key was successfully tagged!\n";
$this->pressEnter();
// 15. Schedule the deletion of the KMS key
echo "\n";
echo "15. Schedule the deletion of the KMS key.\n";
echo "By default, KMS applies a waiting period of 30 days, but you can specify a waiting period of 7-30 days.\n";
echo "When this operation is successful, the key state of the KMS key changes to PendingDeletion and the key can't be used in any cryptographic operations.\n";
echo "It remains in this state for the duration of the waiting period.\n\n";
echo "Deleting a KMS key is a destructive and potentially dangerous operation. When a KMS key is deleted, all data that was encrypted under the KMS key is unrecoverable.\n\n";
$cleanUp = testable_readline("Would you like to delete the resources created during this scenario, including the keys? (y/n): ");
if($cleanUp == "Y" || $cleanUp == "y"){
$this->cleanUp();
}
echo "--------------------------------------------------------------------------------\n";
echo "This concludes the AWS Key Management SDK Basics scenario\n";
echo "--------------------------------------------------------------------------------\n";
namespace Kms;
use Aws\Kms\Exception\KmsException;
use Aws\Kms\KmsClient;
use Aws\Result;
use Aws\ResultPaginator;
use AwsUtilities\AWSServiceClass;
class KmsService extends AWSServiceClass
{
protected KmsClient $client;
protected bool $verbose;
/***
* @param KmsClient|null $client
* @param bool $verbose
*/
public function __construct(KmsClient $client = null, bool $verbose = false)
{
$this->verbose = $verbose;
if($client){
$this->client = $client;
return;
}
$this->client = new KmsClient([]);
}
/***
* @param string $keySpec
* @param string $keyUsage
* @param string $description
* @return array
*/
public function createKey(string $keySpec = "", string $keyUsage = "", string $description = "Created by the SDK for PHP")
{
$parameters = ['Description' => $description];
if($keySpec && $keyUsage){
$parameters['KeySpec'] = $keySpec;
$parameters['KeyUsage'] = $keyUsage;
}
try {
$result = $this->client->createKey($parameters);
return $result['KeyMetadata'];
}catch(KmsException $caught){
// Check for error specific to createKey operations
if ($caught->getAwsErrorMessage() == "LimitExceededException"){
echo "The request was rejected because a quota was exceeded. For more information, see Quotas in the Key Management Service Developer Guide.";
}
throw $caught;
}
}
/***
* @param string $keyId
* @param string $ciphertext
* @param string $algorithm
* @return Result
*/
public function decrypt(string $keyId, string $ciphertext, string $algorithm = "SYMMETRIC_DEFAULT")
{
try{
return $this->client->decrypt([
'CiphertextBlob' => $ciphertext,
'EncryptionAlgorithm' => $algorithm,
'KeyId' => $keyId,
]);
}catch(KmsException $caught){
echo "There was a problem decrypting the data: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
/***
* @param string $keyId
* @param string $text
* @return Result
*/
public function encrypt(string $keyId, string $text)
{
try {
return $this->client->encrypt([
'KeyId' => $keyId,
'Plaintext' => $text,
]);
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "DisabledException"){
echo "The request was rejected because the specified KMS key is not enabled.\n";
}
throw $caught;
}
}
/***
* @param string $keyId
* @param int $limit
* @return ResultPaginator
*/
public function listAliases(string $keyId = "", int $limit = 0)
{
$args = [];
if($keyId){
$args['KeyId'] = $keyId;
}
if($limit){
$args['Limit'] = $limit;
}
try{
return $this->client->getPaginator("ListAliases", $args);
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "InvalidMarkerException"){
echo "The request was rejected because the marker that specifies where pagination should next begin is not valid.\n";
}
throw $caught;
}
}
/***
* @param string $keyId
* @param string $alias
* @return void
*/
public function createAlias(string $keyId, string $alias)
{
try{
$this->client->createAlias([
'TargetKeyId' => $keyId,
'AliasName' => $alias,
]);
}catch (KmsException $caught){
if($caught->getAwsErrorMessage() == "InvalidAliasNameException"){
echo "The request was rejected because the specified alias name is not valid.";
}
throw $caught;
}
}
/***
* @param string $keyId
* @param string $granteePrincipal
* @param array $operations
* @param array $grantTokens
* @return Result
*/
public function createGrant(string $keyId, string $granteePrincipal, array $operations, array $grantTokens = [])
{
$args = [
'KeyId' => $keyId,
'GranteePrincipal' => $granteePrincipal,
'Operations' => $operations,
];
if($grantTokens){
$args['GrantTokens'] = $grantTokens;
}
try{
return $this->client->createGrant($args);
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "InvalidGrantTokenException"){
echo "The request was rejected because the specified grant token is not valid.\n";
}
throw $caught;
}
}
/***
* @param string $keyId
* @return array
*/
public function describeKey(string $keyId)
{
try {
$result = $this->client->describeKey([
"KeyId" => $keyId,
]);
return $result['KeyMetadata'];
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "NotFoundException"){
echo "The request was rejected because the specified entity or resource could not be found.\n";
}
throw $caught;
}
}
/***
* @param string $keyId
* @return void
*/
public function disableKey(string $keyId)
{
try {
$this->client->disableKey([
'KeyId' => $keyId,
]);
}catch(KmsException $caught){
echo "There was a problem disabling the key: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
/***
* @param string $keyId
* @return void
*/
public function enableKey(string $keyId)
{
try {
$this->client->enableKey([
'KeyId' => $keyId,
]);
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "NotFoundException"){
echo "The request was rejected because the specified entity or resource could not be found.\n";
}
throw $caught;
}
}
/***
* @return array
*/
public function listKeys()
{
try {
$contents = [];
$paginator = $this->client->getPaginator("ListKeys");
foreach($paginator as $result){
foreach ($result['Content'] as $object) {
$contents[] = $object;
}
}
return $contents;
}catch(KmsException $caught){
echo "There was a problem listing the keys: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
/***
* @param string $keyId
* @return Result
*/
public function listGrants(string $keyId)
{
try{
return $this->client->listGrants([
'KeyId' => $keyId,
]);
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "NotFoundException"){
echo " The request was rejected because the specified entity or resource could not be found.\n";
}
throw $caught;
}
}
/***
* @param string $keyId
* @return Result
*/
public function getKeyPolicy(string $keyId)
{
try {
return $this->client->getKeyPolicy([
'KeyId' => $keyId,
]);
}catch(KmsException $caught){
echo "There was a problem getting the key policy: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
/***
* @param string $grantId
* @param string $keyId
* @return void
*/
public function revokeGrant(string $grantId, string $keyId)
{
try{
$this->client->revokeGrant([
'GrantId' => $grantId,
'KeyId' => $keyId,
]);
}catch(KmsException $caught){
echo "There was a problem with revoking the grant: {$caught->getAwsErrorMessage()}.\n";
throw $caught;
}
}
/***
* @param string $keyId
* @param int $pendingWindowInDays
* @return void
*/
public function scheduleKeyDeletion(string $keyId, int $pendingWindowInDays = 7)
{
try {
$this->client->scheduleKeyDeletion([
'KeyId' => $keyId,
'PendingWindowInDays' => $pendingWindowInDays,
]);
}catch(KmsException $caught){
echo "There was a problem scheduling the key deletion: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
/***
* @param string $keyId
* @param array $tags
* @return void
*/
public function tagResource(string $keyId, array $tags)
{
try {
$this->client->tagResource([
'KeyId' => $keyId,
'Tags' => $tags,
]);
}catch(KmsException $caught){
echo "There was a problem applying the tag(s): {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
/***
* @param string $keyId
* @param string $message
* @param string $algorithm
* @return Result
*/
public function sign(string $keyId, string $message, string $algorithm)
{
try {
return $this->client->sign([
'KeyId' => $keyId,
'Message' => $message,
'SigningAlgorithm' => $algorithm,
]);
}catch(KmsException $caught){
echo "There was a problem signing the data: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
/***
* @param string $keyId
* @param int $rotationPeriodInDays
* @return void
*/
public function enableKeyRotation(string $keyId, int $rotationPeriodInDays = 365)
{
try{
$this->client->enableKeyRotation([
'KeyId' => $keyId,
'RotationPeriodInDays' => $rotationPeriodInDays,
]);
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "NotFoundException"){
echo "The request was rejected because the specified entity or resource could not be found.\n";
}
throw $caught;
}
}
/***
* @param string $keyId
* @param string $policy
* @return void
*/
public function putKeyPolicy(string $keyId, string $policy)
{
try {
$this->client->putKeyPolicy([
'KeyId' => $keyId,
'Policy' => $policy,
]);
}catch(KmsException $caught){
echo "There was a problem replacing the key policy: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
/***
* @param string $aliasName
* @return void
*/
public function deleteAlias(string $aliasName)
{
try {
$this->client->deleteAlias([
'AliasName' => $aliasName,
]);
}catch(KmsException $caught){
echo "There was a problem deleting the alias: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
/***
* @param string $keyId
* @param string $message
* @param string $signature
* @param string $signingAlgorithm
* @return bool
*/
public function verify(string $keyId, string $message, string $signature, string $signingAlgorithm)
{
try {
$result = $this->client->verify([
'KeyId' => $keyId,
'Message' => $message,
'Signature' => $signature,
'SigningAlgorithm' => $signingAlgorithm,
]);
return $result['SignatureValid'];
}catch(KmsException $caught){
echo "There was a problem verifying the signature: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
}
```
+ Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per PHP *.
+ [CreateAlias](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateAlias)
+ [CreateGrant](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateGrant)
+ [CreateKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateKey)
+ [Decrypt](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Decrypt)
+ [DescribeKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/DescribeKey)
+ [DisableKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/DisableKey)
+ [EnableKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/EnableKey)
+ [Encrypt](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Encrypt)
+ [GetKeyPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/GetKeyPolicy)
+ [ListAliases](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListAliases)
+ [ListGrants](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListGrants)
+ [ListKeys](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListKeys)
+ [RevokeGrant](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/RevokeGrant)
+ [ScheduleKeyDeletion](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ScheduleKeyDeletion)
+ [Sign](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Sign)
+ [TagResource](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/TagResource)
## Azioni
### `CreateAlias`
Il seguente esempio di codice mostra come usare`CreateAlias`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @param string $alias
* @return void
*/
public function createAlias(string $keyId, string $alias)
{
try{
$this->client->createAlias([
'TargetKeyId' => $keyId,
'AliasName' => $alias,
]);
}catch (KmsException $caught){
if($caught->getAwsErrorMessage() == "InvalidAliasNameException"){
echo "The request was rejected because the specified alias name is not valid.";
}
throw $caught;
}
}
```
+ Per i dettagli sull'API, [CreateAlias](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateAlias)consulta *AWS SDK per PHP API Reference*.
### `CreateGrant`
Il seguente esempio di codice mostra come utilizzare`CreateGrant`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @param string $granteePrincipal
* @param array $operations
* @param array $grantTokens
* @return Result
*/
public function createGrant(string $keyId, string $granteePrincipal, array $operations, array $grantTokens = [])
{
$args = [
'KeyId' => $keyId,
'GranteePrincipal' => $granteePrincipal,
'Operations' => $operations,
];
if($grantTokens){
$args['GrantTokens'] = $grantTokens;
}
try{
return $this->client->createGrant($args);
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "InvalidGrantTokenException"){
echo "The request was rejected because the specified grant token is not valid.\n";
}
throw $caught;
}
}
```
+ Per i dettagli sull'API, [CreateGrant](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateGrant)consulta *AWS SDK per PHP API Reference*.
### `CreateKey`
Il seguente esempio di codice mostra come utilizzare`CreateKey`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keySpec
* @param string $keyUsage
* @param string $description
* @return array
*/
public function createKey(string $keySpec = "", string $keyUsage = "", string $description = "Created by the SDK for PHP")
{
$parameters = ['Description' => $description];
if($keySpec && $keyUsage){
$parameters['KeySpec'] = $keySpec;
$parameters['KeyUsage'] = $keyUsage;
}
try {
$result = $this->client->createKey($parameters);
return $result['KeyMetadata'];
}catch(KmsException $caught){
// Check for error specific to createKey operations
if ($caught->getAwsErrorMessage() == "LimitExceededException"){
echo "The request was rejected because a quota was exceeded. For more information, see Quotas in the Key Management Service Developer Guide.";
}
throw $caught;
}
}
```
+ Per i dettagli sull'API, [CreateKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateKey)consulta *AWS SDK per PHP API Reference*.
### `Decrypt`
Il seguente esempio di codice mostra come utilizzare`Decrypt`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @param string $ciphertext
* @param string $algorithm
* @return Result
*/
public function decrypt(string $keyId, string $ciphertext, string $algorithm = "SYMMETRIC_DEFAULT")
{
try{
return $this->client->decrypt([
'CiphertextBlob' => $ciphertext,
'EncryptionAlgorithm' => $algorithm,
'KeyId' => $keyId,
]);
}catch(KmsException $caught){
echo "There was a problem decrypting the data: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
```
+ Per informazioni dettagliate sull’API, consulta [Decrypt](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Decrypt) nella *documentazione di riferimento dell’API AWS SDK per PHP *.
### `DeleteAlias`
Il seguente esempio di codice mostra come usare`DeleteAlias`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $aliasName
* @return void
*/
public function deleteAlias(string $aliasName)
{
try {
$this->client->deleteAlias([
'AliasName' => $aliasName,
]);
}catch(KmsException $caught){
echo "There was a problem deleting the alias: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
```
+ Per i dettagli sull'API, [DeleteAlias](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/DeleteAlias)consulta *AWS SDK per PHP API Reference*.
### `DescribeKey`
Il seguente esempio di codice mostra come utilizzare`DescribeKey`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @return array
*/
public function describeKey(string $keyId)
{
try {
$result = $this->client->describeKey([
"KeyId" => $keyId,
]);
return $result['KeyMetadata'];
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "NotFoundException"){
echo "The request was rejected because the specified entity or resource could not be found.\n";
}
throw $caught;
}
}
```
+ Per i dettagli sull'API, [DescribeKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/DescribeKey)consulta *AWS SDK per PHP API Reference*.
### `DisableKey`
Il seguente esempio di codice mostra come utilizzare`DisableKey`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @return void
*/
public function disableKey(string $keyId)
{
try {
$this->client->disableKey([
'KeyId' => $keyId,
]);
}catch(KmsException $caught){
echo "There was a problem disabling the key: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
```
+ Per i dettagli sull'API, [DisableKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/DisableKey)consulta *AWS SDK per PHP API Reference*.
### `EnableKey`
Il seguente esempio di codice mostra come utilizzare`EnableKey`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @return void
*/
public function enableKey(string $keyId)
{
try {
$this->client->enableKey([
'KeyId' => $keyId,
]);
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "NotFoundException"){
echo "The request was rejected because the specified entity or resource could not be found.\n";
}
throw $caught;
}
}
```
+ Per i dettagli sull'API, [EnableKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/EnableKey)consulta *AWS SDK per PHP API Reference*.
### `Encrypt`
Il seguente esempio di codice mostra come utilizzare`Encrypt`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @param string $text
* @return Result
*/
public function encrypt(string $keyId, string $text)
{
try {
return $this->client->encrypt([
'KeyId' => $keyId,
'Plaintext' => $text,
]);
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "DisabledException"){
echo "The request was rejected because the specified KMS key is not enabled.\n";
}
throw $caught;
}
}
```
+ Per informazioni dettagliate sull’API, consulta [Encrypt](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Encrypt) nella *documentazione di riferimento dell’API AWS SDK per PHP *.
### `ListAliases`
Il seguente esempio di codice mostra come usare`ListAliases`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @param int $limit
* @return ResultPaginator
*/
public function listAliases(string $keyId = "", int $limit = 0)
{
$args = [];
if($keyId){
$args['KeyId'] = $keyId;
}
if($limit){
$args['Limit'] = $limit;
}
try{
return $this->client->getPaginator("ListAliases", $args);
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "InvalidMarkerException"){
echo "The request was rejected because the marker that specifies where pagination should next begin is not valid.\n";
}
throw $caught;
}
}
```
+ Per i dettagli sull'API, [ListAliases](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListAliases)consulta *AWS SDK per PHP API Reference*.
### `ListGrants`
Il seguente esempio di codice mostra come utilizzare`ListGrants`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @return Result
*/
public function listGrants(string $keyId)
{
try{
return $this->client->listGrants([
'KeyId' => $keyId,
]);
}catch(KmsException $caught){
if($caught->getAwsErrorMessage() == "NotFoundException"){
echo " The request was rejected because the specified entity or resource could not be found.\n";
}
throw $caught;
}
}
```
+ Per i dettagli sull'API, [ListGrants](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListGrants)consulta *AWS SDK per PHP API Reference*.
### `ListKeys`
Il seguente esempio di codice mostra come utilizzare`ListKeys`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @return array
*/
public function listKeys()
{
try {
$contents = [];
$paginator = $this->client->getPaginator("ListKeys");
foreach($paginator as $result){
foreach ($result['Content'] as $object) {
$contents[] = $object;
}
}
return $contents;
}catch(KmsException $caught){
echo "There was a problem listing the keys: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
```
+ Per i dettagli sull'API, [ListKeys](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListKeys)consulta *AWS SDK per PHP API Reference*.
### `PutKeyPolicy`
Il seguente esempio di codice mostra come utilizzare`PutKeyPolicy`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @param string $policy
* @return void
*/
public function putKeyPolicy(string $keyId, string $policy)
{
try {
$this->client->putKeyPolicy([
'KeyId' => $keyId,
'Policy' => $policy,
]);
}catch(KmsException $caught){
echo "There was a problem replacing the key policy: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
```
+ Per i dettagli sull'API, [PutKeyPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/PutKeyPolicy)consulta *AWS SDK per PHP API Reference*.
### `RevokeGrant`
Il seguente esempio di codice mostra come utilizzare`RevokeGrant`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $grantId
* @param string $keyId
* @return void
*/
public function revokeGrant(string $grantId, string $keyId)
{
try{
$this->client->revokeGrant([
'GrantId' => $grantId,
'KeyId' => $keyId,
]);
}catch(KmsException $caught){
echo "There was a problem with revoking the grant: {$caught->getAwsErrorMessage()}.\n";
throw $caught;
}
}
```
+ Per i dettagli sull'API, [RevokeGrant](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/RevokeGrant)consulta *AWS SDK per PHP API Reference*.
### `ScheduleKeyDeletion`
Il seguente esempio di codice mostra come utilizzare`ScheduleKeyDeletion`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @param int $pendingWindowInDays
* @return void
*/
public function scheduleKeyDeletion(string $keyId, int $pendingWindowInDays = 7)
{
try {
$this->client->scheduleKeyDeletion([
'KeyId' => $keyId,
'PendingWindowInDays' => $pendingWindowInDays,
]);
}catch(KmsException $caught){
echo "There was a problem scheduling the key deletion: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
```
+ Per i dettagli sull'API, [ScheduleKeyDeletion](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ScheduleKeyDeletion)consulta *AWS SDK per PHP API Reference*.
### `Sign`
Il seguente esempio di codice mostra come utilizzare`Sign`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @param string $message
* @param string $algorithm
* @return Result
*/
public function sign(string $keyId, string $message, string $algorithm)
{
try {
return $this->client->sign([
'KeyId' => $keyId,
'Message' => $message,
'SigningAlgorithm' => $algorithm,
]);
}catch(KmsException $caught){
echo "There was a problem signing the data: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
```
+ Per informazioni dettagliate sull’API, consulta [Sign](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Sign) nella *documentazione di riferimento dell’API AWS SDK per PHP *.
### `TagResource`
Il seguente esempio di codice mostra come usare`TagResource`.
**SDK per PHP**
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/php/example_code/kms#code-examples).
```
/***
* @param string $keyId
* @param array $tags
* @return void
*/
public function tagResource(string $keyId, array $tags)
{
try {
$this->client->tagResource([
'KeyId' => $keyId,
'Tags' => $tags,
]);
}catch(KmsException $caught){
echo "There was a problem applying the tag(s): {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
}
```
+ Per i dettagli sull'API, [TagResource](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/TagResource)consulta *AWS SDK per PHP API Reference*.
# Esempi per Lambda con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP with Lambda.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
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**
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
+ [Scenari](#scenarios)
+ [Esempi serverless](#serverless_examples)
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come:
+ Crea un ruolo IAM e una funzione Lambda, quindi carica il codice del gestore.
+ Invocare la funzione con un singolo parametro e ottenere i risultati.
+ Aggiorna il codice della funzione e configuralo con una variabile di ambiente.
+ Invocare la funzione con nuovi parametri e ottenere i risultati. Visualizza il log di esecuzione restituito.
+ Elenca le funzioni dell’account, quindi elimina le risorse.
Per ulteriori informazioni, consulta [Creare una funzione Lambda con la console](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html).
**SDK per PHP**
C'è di più 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/php/example_code/lambda#code-examples).
```
namespace Lambda;
use Aws\S3\S3Client;
use GuzzleHttp\Psr7\Stream;
use Iam\IAMService;
class GettingStartedWithLambda
{
public function run()
{
echo("\n");
echo("--------------------------------------\n");
print("Welcome to the AWS Lambda getting started demo using PHP!\n");
echo("--------------------------------------\n");
$clientArgs = [
'region' => 'us-west-2',
'version' => 'latest',
'profile' => 'default',
];
$uniqid = uniqid();
$iamService = new IAMService();
$s3client = new S3Client($clientArgs);
$lambdaService = new LambdaService();
echo "First, let's create a role to run our Lambda code.\n";
$roleName = "test-lambda-role-$uniqid";
$rolePolicyDocument = "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Principal\": {
\"Service\": \"lambda.amazonaws.com\"
},
\"Action\": \"sts:AssumeRole\"
}
]
}";
$role = $iamService->createRole($roleName, $rolePolicyDocument);
echo "Created role {$role['RoleName']}.\n";
$iamService->attachRolePolicy(
$role['RoleName'],
"arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
);
echo "Attached the AWSLambdaBasicExecutionRole to {$role['RoleName']}.\n";
echo "\nNow let's create an S3 bucket and upload our Lambda code there.\n";
$bucketName = "amzn-s3-demo-bucket-$uniqid";
$s3client->createBucket([
'Bucket' => $bucketName,
]);
echo "Created bucket $bucketName.\n";
$functionName = "doc_example_lambda_$uniqid";
$codeBasic = __DIR__ . "/lambda_handler_basic.zip";
$handler = "lambda_handler_basic";
$file = file_get_contents($codeBasic);
$s3client->putObject([
'Bucket' => $bucketName,
'Key' => $functionName,
'Body' => $file,
]);
echo "Uploaded the Lambda code.\n";
$createLambdaFunction = $lambdaService->createFunction($functionName, $role, $bucketName, $handler);
// Wait until the function has finished being created.
do {
$getLambdaFunction = $lambdaService->getFunction($createLambdaFunction['FunctionName']);
} while ($getLambdaFunction['Configuration']['State'] == "Pending");
echo "Created Lambda function {$getLambdaFunction['Configuration']['FunctionName']}.\n";
sleep(1);
echo "\nOk, let's invoke that Lambda code.\n";
$basicParams = [
'action' => 'increment',
'number' => 3,
];
/** @var Stream $invokeFunction */
$invokeFunction = $lambdaService->invoke($functionName, $basicParams)['Payload'];
$result = json_decode($invokeFunction->getContents())->result;
echo "After invoking the Lambda code with the input of {$basicParams['number']} we received $result.\n";
echo "\nSince that's working, let's update the Lambda code.\n";
$codeCalculator = "lambda_handler_calculator.zip";
$handlerCalculator = "lambda_handler_calculator";
echo "First, put the new code into the S3 bucket.\n";
$file = file_get_contents($codeCalculator);
$s3client->putObject([
'Bucket' => $bucketName,
'Key' => $functionName,
'Body' => $file,
]);
echo "New code uploaded.\n";
$lambdaService->updateFunctionCode($functionName, $bucketName, $functionName);
// Wait for the Lambda code to finish updating.
do {
$getLambdaFunction = $lambdaService->getFunction($createLambdaFunction['FunctionName']);
} while ($getLambdaFunction['Configuration']['LastUpdateStatus'] !== "Successful");
echo "New Lambda code uploaded.\n";
$environment = [
'Variable' => ['Variables' => ['LOG_LEVEL' => 'DEBUG']],
];
$lambdaService->updateFunctionConfiguration($functionName, $handlerCalculator, $environment);
do {
$getLambdaFunction = $lambdaService->getFunction($createLambdaFunction['FunctionName']);
} while ($getLambdaFunction['Configuration']['LastUpdateStatus'] !== "Successful");
echo "Lambda code updated with new handler and a LOG_LEVEL of DEBUG for more information.\n";
echo "Invoke the new code with some new data.\n";
$calculatorParams = [
'action' => 'plus',
'x' => 5,
'y' => 4,
];
$invokeFunction = $lambdaService->invoke($functionName, $calculatorParams, "Tail");
$result = json_decode($invokeFunction['Payload']->getContents())->result;
echo "Indeed, {$calculatorParams['x']} + {$calculatorParams['y']} does equal $result.\n";
echo "Here's the extra debug info: ";
echo base64_decode($invokeFunction['LogResult']) . "\n";
echo "\nBut what happens if you try to divide by zero?\n";
$divZeroParams = [
'action' => 'divide',
'x' => 5,
'y' => 0,
];
$invokeFunction = $lambdaService->invoke($functionName, $divZeroParams, "Tail");
$result = json_decode($invokeFunction['Payload']->getContents())->result;
echo "You get a |$result| result.\n";
echo "And an error message: ";
echo base64_decode($invokeFunction['LogResult']) . "\n";
echo "\nHere's all the Lambda functions you have in this Region:\n";
$listLambdaFunctions = $lambdaService->listFunctions(5);
$allLambdaFunctions = $listLambdaFunctions['Functions'];
$next = $listLambdaFunctions->get('NextMarker');
while ($next != false) {
$listLambdaFunctions = $lambdaService->listFunctions(5, $next);
$next = $listLambdaFunctions->get('NextMarker');
$allLambdaFunctions = array_merge($allLambdaFunctions, $listLambdaFunctions['Functions']);
}
foreach ($allLambdaFunctions as $function) {
echo "{$function['FunctionName']}\n";
}
echo "\n\nAnd don't forget to clean up your data!\n";
$lambdaService->deleteFunction($functionName);
echo "Deleted Lambda function.\n";
$iamService->deleteRole($role['RoleName']);
echo "Deleted Role.\n";
$deleteObjects = $s3client->listObjectsV2([
'Bucket' => $bucketName,
]);
$deleteObjects = $s3client->deleteObjects([
'Bucket' => $bucketName,
'Delete' => [
'Objects' => $deleteObjects['Contents'],
]
]);
echo "Deleted all objects from the S3 bucket.\n";
$s3client->deleteBucket(['Bucket' => $bucketName]);
echo "Deleted the bucket.\n";
}
}
```
+ Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per PHP *.
+ [CreateFunction](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/CreateFunction)
+ [DeleteFunction](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/DeleteFunction)
+ [GetFunction](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/GetFunction)
+ [Invoke](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/Invoke)
+ [ListFunctions](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/ListFunctions)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/UpdateFunctionCode)
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/UpdateFunctionConfiguration)
## Azioni
### `CreateFunction`
Il seguente esempio di codice mostra come usare`CreateFunction`.
**SDK per PHP**
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/php/example_code/lambda#code-examples).
```
public function createFunction($functionName, $role, $bucketName, $handler)
{
//This assumes the Lambda function is in an S3 bucket.
return $this->customWaiter(function () use ($functionName, $role, $bucketName, $handler) {
return $this->lambdaClient->createFunction([
'Code' => [
'S3Bucket' => $bucketName,
'S3Key' => $functionName,
],
'FunctionName' => $functionName,
'Role' => $role['Arn'],
'Runtime' => 'python3.9',
'Handler' => "$handler.lambda_handler",
]);
});
}
```
+ Per i dettagli sull'API, [CreateFunction](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/CreateFunction)consulta *AWS SDK per PHP API Reference*.
### `DeleteFunction`
Il seguente esempio di codice mostra come utilizzare`DeleteFunction`.
**SDK per PHP**
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/php/example_code/lambda#code-examples).
```
public function deleteFunction($functionName)
{
return $this->lambdaClient->deleteFunction([
'FunctionName' => $functionName,
]);
}
```
+ Per i dettagli sull'API, [DeleteFunction](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/DeleteFunction)consulta *AWS SDK per PHP API Reference*.
### `GetFunction`
Il seguente esempio di codice mostra come utilizzare`GetFunction`.
**SDK per PHP**
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/php/example_code/lambda#code-examples).
```
public function getFunction($functionName)
{
return $this->lambdaClient->getFunction([
'FunctionName' => $functionName,
]);
}
```
+ Per i dettagli sull'API, [GetFunction](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/GetFunction)consulta *AWS SDK per PHP API Reference*.
### `Invoke`
Il seguente esempio di codice mostra come utilizzare`Invoke`.
**SDK per PHP**
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/php/example_code/lambda#code-examples).
```
public function invoke($functionName, $params, $logType = 'None')
{
return $this->lambdaClient->invoke([
'FunctionName' => $functionName,
'Payload' => json_encode($params),
'LogType' => $logType,
]);
}
```
+ Per informazioni dettagliate sull’API, consulta [Invoke](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/Invoke) nella *documentazione di riferimento dell’API AWS SDK per PHP *.
### `ListFunctions`
Il seguente esempio di codice mostra come usare`ListFunctions`.
**SDK per PHP**
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/php/example_code/lambda#code-examples).
```
public function listFunctions($maxItems = 50, $marker = null)
{
if (is_null($marker)) {
return $this->lambdaClient->listFunctions([
'MaxItems' => $maxItems,
]);
}
return $this->lambdaClient->listFunctions([
'Marker' => $marker,
'MaxItems' => $maxItems,
]);
}
```
+ Per i dettagli sull'API, [ListFunctions](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/ListFunctions)consulta *AWS SDK per PHP API Reference*.
### `UpdateFunctionCode`
Il seguente esempio di codice mostra come utilizzare`UpdateFunctionCode`.
**SDK per PHP**
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/php/example_code/lambda#code-examples).
```
public function updateFunctionCode($functionName, $s3Bucket, $s3Key)
{
return $this->lambdaClient->updateFunctionCode([
'FunctionName' => $functionName,
'S3Bucket' => $s3Bucket,
'S3Key' => $s3Key,
]);
}
```
+ Per i dettagli sull'API, [UpdateFunctionCode](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/UpdateFunctionCode)consulta *AWS SDK per PHP API Reference*.
### `UpdateFunctionConfiguration`
Il seguente esempio di codice mostra come utilizzare`UpdateFunctionConfiguration`.
**SDK per PHP**
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/php/example_code/lambda#code-examples).
```
public function updateFunctionConfiguration($functionName, $handler, $environment = '')
{
return $this->lambdaClient->updateFunctionConfiguration([
'FunctionName' => $functionName,
'Handler' => "$handler.lambda_handler",
'Environment' => $environment,
]);
}
```
+ Per i dettagli sull'API, [UpdateFunctionConfiguration](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/UpdateFunctionConfiguration)consulta *AWS SDK per PHP API Reference*.
## Scenari
### Creazione di un’applicazione serverless per gestire foto
L’esempio di codice seguente mostra come creare un’applicazione serverless che consente agli utenti di gestire le foto mediante etichette.
**SDK per PHP**
Mostra come sviluppare un’applicazione per la gestione delle risorse fotografiche che rileva le etichette nelle immagini utilizzando Amazon Rekognition e le archivia per recuperarle in seguito.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Per approfondire l’origine di questo esempio, consulta il post su [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servizi utilizzati in questo esempio**
+ Gateway API
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Simple Storage Service (Amazon S3)
+ Amazon SNS
## Esempi serverless
### Connessione a un database Amazon RDS in una funzione Lambda
L’esempio di codice seguente mostra come implementare una funzione Lambda che si connette a un database RDS. La funzione effettua una semplice richiesta al database e restituisce il risultato.
**SDK per PHP**
C'è altro su GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Connessione a un database Amazon RDS in una funzione Lambda tramite PHP.
```
logger = $logger;
}
private function getAuthToken(): string {
// Define connection authentication parameters
$dbConnection = [
'hostname' => getenv('DB_HOSTNAME'),
'port' => getenv('DB_PORT'),
'username' => getenv('DB_USERNAME'),
'region' => getenv('AWS_REGION'),
];
// Create RDS AuthTokenGenerator object
$generator = new AuthTokenGenerator(CredentialProvider::defaultProvider());
// Request authorization token from RDS, specifying the username
return $generator->createToken(
$dbConnection['hostname'] . ':' . $dbConnection['port'],
$dbConnection['region'],
$dbConnection['username']
);
}
private function getQueryResults() {
// Obtain auth token
$token = $this->getAuthToken();
// Define connection configuration
$connectionConfig = [
'host' => getenv('DB_HOSTNAME'),
'user' => getenv('DB_USERNAME'),
'password' => $token,
'database' => getenv('DB_NAME'),
];
// Create the connection to the DB
$conn = new PDO(
"mysql:host={$connectionConfig['host']};dbname={$connectionConfig['database']}",
$connectionConfig['user'],
$connectionConfig['password'],
[
PDO::MYSQL_ATTR_SSL_CA => '/path/to/rds-ca-2019-root.pem',
PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true,
]
);
// Obtain the result of the query
$stmt = $conn->prepare('SELECT ?+? AS sum');
$stmt->execute([3, 2]);
return $stmt->fetch(PDO::FETCH_ASSOC);
}
/**
* @param mixed $event
* @param Context $context
* @return array
*/
public function handle(mixed $event, Context $context): array
{
$this->logger->info("Processing query");
// Execute database flow
$result = $this->getQueryResults();
return [
'sum' => $result['sum']
];
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
### Invocare una funzione Lambda da un trigger Kinesis
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di record da un flusso Kinesis. La funzione recupera il payload Kinesis, lo decodifica da Base64 e registra il contenuto del record.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda).
Utilizzo di un evento Kinesis con Lambda tramite PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
logger = $logger;
}
/**
* @throws JsonException
* @throws \Bref\Event\InvalidLambdaEvent
*/
public function handleKinesis(KinesisEvent $event, Context $context): void
{
$this->logger->info("Processing records");
$records = $event->getRecords();
foreach ($records as $record) {
$data = $record->getData();
$this->logger->info(json_encode($data));
// TODO: Do interesting work based on the new data
// Any exception thrown will be logged and the invocation will be marked as failed
}
$totalRecords = count($records);
$this->logger->info("Successfully processed $totalRecords records");
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
### Invocare una funzione Lambda da un trigger DynamoDB
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di record da un flusso DynamoDB. La funzione recupera il payload DynamoDB e registra il contenuto del record.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda).
Utilizzo di un evento DynamoDB con Lambda tramite PHP.
```
logger = $logger;
}
/**
* @throws JsonException
* @throws \Bref\Event\InvalidLambdaEvent
*/
public function handleDynamoDb(DynamoDbEvent $event, Context $context): void
{
$this->logger->info("Processing DynamoDb table items");
$records = $event->getRecords();
foreach ($records as $record) {
$eventName = $record->getEventName();
$keys = $record->getKeys();
$old = $record->getOldImage();
$new = $record->getNewImage();
$this->logger->info("Event Name:".$eventName."\n");
$this->logger->info("Keys:". json_encode($keys)."\n");
$this->logger->info("Old Image:". json_encode($old)."\n");
$this->logger->info("New Image:". json_encode($new));
// TODO: Do interesting work based on the new data
// Any exception thrown will be logged and the invocation will be marked as failed
}
$totalRecords = count($records);
$this->logger->info("Successfully processed $totalRecords items");
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
### Invocare una funzione Lambda da un trigger Amazon DocumentDB
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di record da un flusso di modifiche di DocumentDB. La funzione recupera il payload DocumentDB e registra il contenuto del record.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Utilizzo di un evento Amazon DocumentDB con Lambda tramite PHP.
```
logDocumentDBEvent($record['event']);
}
return 'OK';
}
private function logDocumentDBEvent($event): void
{
// Extract information from the event record
$operationType = $event['operationType'] ?? 'Unknown';
$db = $event['ns']['db'] ?? 'Unknown';
$collection = $event['ns']['coll'] ?? 'Unknown';
$fullDocument = $event['fullDocument'] ?? [];
// Log the event details
echo "Operation type: $operationType\n";
echo "Database: $db\n";
echo "Collection: $collection\n";
echo "Full document: " . json_encode($fullDocument, JSON_PRETTY_PRINT) . "\n";
}
}
return new DocumentDBEventHandler();
```
### Invocare una funzione Lambda da un trigger Amazon MSK
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di record da un cluster Amazon MSK. La funzione recupera il payload MSK e registra il contenuto del record.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda).
Utilizzo di un evento Amazon MSK con Lambda tramite PHP.
```
logger = $logger;
}
/**
* @throws JsonException
* @throws \Bref\Event\InvalidLambdaEvent
*/
public function handle(mixed $event, Context $context): void
{
$kafkaEvent = new KafkaEvent($event);
$this->logger->info("Processing records");
$records = $kafkaEvent->getRecords();
foreach ($records as $record) {
try {
$key = $record->getKey();
$this->logger->info("Key: $key");
$values = $record->getValue();
$this->logger->info(json_encode($values));
foreach ($values as $value) {
$this->logger->info("Value: $value");
}
} catch (Exception $e) {
$this->logger->error($e->getMessage());
}
}
$totalRecords = count($records);
$this->logger->info("Successfully processed $totalRecords records");
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
### Invocazione di una funzione Lambda da un trigger Amazon S3
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dal caricamento di un oggetto in un bucket S3. La funzione recupera il nome del bucket S3 e la chiave dell’oggetto dal parametro evento e chiama l’API Amazon S3 per recuperare e registrare il tipo di contenuto dell’oggetto.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Utilizzo di un evento S3 con Lambda tramite PHP.
```
logger = $logger;
}
public function handleS3(S3Event $event, Context $context) : void
{
$this->logger->info("Processing S3 records");
// Get the object from the event and show its content type
$records = $event->getRecords();
foreach ($records as $record)
{
$bucket = $record->getBucket()->getName();
$key = urldecode($record->getObject()->getKey());
try {
$fileSize = urldecode($record->getObject()->getSize());
echo "File Size: " . $fileSize . "\n";
// TODO: Implement your custom processing logic here
} catch (Exception $e) {
echo $e->getMessage() . "\n";
echo 'Error getting object ' . $key . ' from bucket ' . $bucket . '. Make sure they exist and your bucket is in the same region as this function.' . "\n";
throw $e;
}
}
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
### Invocazione di una funzione Lambda da un trigger Amazon SNS
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dal ricevimento di messaggi da un argomento SNS. La funzione recupera i messaggi dal parametro dell’evento e registra il contenuto di ogni messaggio.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Utilizzo di un evento SNS con Lambda tramite PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
getRecords() as $record) {
$message = $record->getMessage();
// TODO: Implement your custom processing logic here
// Any exception thrown will be logged and the invocation will be marked as failed
echo "Processed Message: $message" . PHP_EOL;
}
}
}
return new Handler();
```
### Invocazione di una funzione Lambda da un trigger Amazon SQS
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di messaggi da una coda SQS. La funzione recupera i messaggi dal parametro dell’evento e registra il contenuto di ogni messaggio.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Utilizzo di un evento SQS con Lambda tramite PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
logger = $logger;
}
/**
* @throws InvalidLambdaEvent
*/
public function handleSqs(SqsEvent $event, Context $context): void
{
foreach ($event->getRecords() as $record) {
$body = $record->getBody();
// TODO: Do interesting work based on the new message
}
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
### Segnalazione di errori di elementi batch per funzioni Lambda con un trigger Kinesis
L’esempio di codice seguente mostra come implementare una risposta batch parziale per funzioni Lambda che ricevono eventi da un flusso Kinesis. La funzione riporta gli errori degli elementi batch nella risposta, segnalando a Lambda di riprovare tali messaggi in un secondo momento.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda-with-batch-item-handling).
Segnalazione di errori di elementi batch di Kinesis con Lambda tramite PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
logger = $logger;
}
/**
* @throws JsonException
* @throws \Bref\Event\InvalidLambdaEvent
*/
public function handle(mixed $event, Context $context): array
{
$kinesisEvent = new KinesisEvent($event);
$this->logger->info("Processing records");
$records = $kinesisEvent->getRecords();
$failedRecords = [];
foreach ($records as $record) {
try {
$data = $record->getData();
$this->logger->info(json_encode($data));
// TODO: Do interesting work based on the new data
} catch (Exception $e) {
$this->logger->error($e->getMessage());
// failed processing the record
$failedRecords[] = $record->getSequenceNumber();
}
}
$totalRecords = count($records);
$this->logger->info("Successfully processed $totalRecords records");
// change format for the response
$failures = array_map(
fn(string $sequenceNumber) => ['itemIdentifier' => $sequenceNumber],
$failedRecords
);
return [
'batchItemFailures' => $failures
];
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
### Segnalazione di errori di elementi batch per funzioni Lambda con un trigger DynamoDB
L’esempio di codice seguente mostra come implementare una risposta batch parziale per funzioni Lambda che ricevono eventi da un flusso DynamoDB. La funzione riporta gli errori degli elementi batch nella risposta, segnalando a Lambda di riprovare tali messaggi in un secondo momento.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda-with-batch-item-handling).
Segnalazione di errori di elementi batch di DynamoDB con Lambda tramite PHP.
```
logger = $logger;
}
/**
* @throws JsonException
* @throws \Bref\Event\InvalidLambdaEvent
*/
public function handle(mixed $event, Context $context): array
{
$dynamoDbEvent = new DynamoDbEvent($event);
$this->logger->info("Processing records");
$records = $dynamoDbEvent->getRecords();
$failedRecords = [];
foreach ($records as $record) {
try {
$data = $record->getData();
$this->logger->info(json_encode($data));
// TODO: Do interesting work based on the new data
} catch (Exception $e) {
$this->logger->error($e->getMessage());
// failed processing the record
$failedRecords[] = $record->getSequenceNumber();
}
}
$totalRecords = count($records);
$this->logger->info("Successfully processed $totalRecords records");
// change format for the response
$failures = array_map(
fn(string $sequenceNumber) => ['itemIdentifier' => $sequenceNumber],
$failedRecords
);
return [
'batchItemFailures' => $failures
];
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
### Segnalazione di errori di elementi batch per funzioni Lambda con un trigger Amazon SQS
L’esempio di codice seguente mostra come implementare una risposta batch parziale per funzioni Lambda che ricevono eventi da una coda SQS. La funzione riporta gli errori degli elementi batch nella risposta, segnalando a Lambda di riprovare tali messaggi in un secondo momento.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures).
Segnalazione di errori di elementi batch di SQS con Lambda tramite PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
logger = $logger;
}
/**
* @throws JsonException
* @throws \Bref\Event\InvalidLambdaEvent
*/
public function handleSqs(SqsEvent $event, Context $context): void
{
$this->logger->info("Processing SQS records");
$records = $event->getRecords();
foreach ($records as $record) {
try {
// Assuming the SQS message is in JSON format
$message = json_decode($record->getBody(), true);
$this->logger->info(json_encode($message));
// TODO: Implement your custom processing logic here
} catch (Exception $e) {
$this->logger->error($e->getMessage());
// failed processing the record
$this->markAsFailed($record);
}
}
$totalRecords = count($records);
$this->logger->info("Successfully processed $totalRecords SQS records");
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
# Esempi per Amazon MSK con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP con Amazon MSK.
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**
+ [Esempi serverless](#serverless_examples)
## Esempi serverless
### Invocare una funzione Lambda da un trigger Amazon MSK
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di record da un cluster Amazon MSK. La funzione recupera il payload MSK e registra il contenuto del record.
**SDK per PHP**
C'è di più su. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda).
Utilizzo di un evento Amazon MSK con Lambda tramite PHP.
```
logger = $logger;
}
/**
* @throws JsonException
* @throws \Bref\Event\InvalidLambdaEvent
*/
public function handle(mixed $event, Context $context): void
{
$kafkaEvent = new KafkaEvent($event);
$this->logger->info("Processing records");
$records = $kafkaEvent->getRecords();
foreach ($records as $record) {
try {
$key = $record->getKey();
$this->logger->info("Key: $key");
$values = $record->getValue();
$this->logger->info(json_encode($values));
foreach ($values as $value) {
$this->logger->info("Value: $value");
}
} catch (Exception $e) {
$this->logger->error($e->getMessage());
}
}
$totalRecords = count($records);
$this->logger->info("Successfully processed $totalRecords records");
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
# Esempi per Amazon RDS con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando Amazon RDS. AWS SDK per PHP
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)
+ [Esempi serverless](#serverless_examples)
## Azioni
### `CreateDBInstance`
Il seguente esempio di codice mostra come usare`CreateDBInstance`.
**SDK per PHP**
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/php/example_code/rds#code-examples).
```
require __DIR__ . '/vendor/autoload.php';
use Aws\Exception\AwsException;
$rdsClient = new Aws\Rds\RdsClient([
'region' => 'us-east-2'
]);
$dbIdentifier = '<<{{db-identifier}}>>';
$dbClass = 'db.t2.micro';
$storage = 5;
$engine = 'MySQL';
$username = 'MyUser';
$password = 'MyPassword';
try {
$result = $rdsClient->createDBInstance([
'DBInstanceIdentifier' => $dbIdentifier,
'DBInstanceClass' => $dbClass,
'AllocatedStorage' => $storage,
'Engine' => $engine,
'MasterUsername' => $username,
'MasterUserPassword' => $password,
]);
var_dump($result);
} catch (AwsException $e) {
echo $e->getMessage();
echo "\n";
}
```
+ Per i dettagli sull'API, consulta [Create DBInstance](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/CreateDBInstance) in *AWS SDK per PHP API Reference*.
### `CreateDBSnapshot`
Il seguente esempio di codice mostra come utilizzare`CreateDBSnapshot`.
**SDK per PHP**
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/php/example_code/rds#code-examples).
```
require __DIR__ . '/vendor/autoload.php';
use Aws\Exception\AwsException;
$rdsClient = new Aws\Rds\RdsClient([
'region' => 'us-east-2'
]);
$dbIdentifier = '<<{{db-identifier}}>>';
$snapshotName = '<<{{backup_2018_12_25}}>>';
try {
$result = $rdsClient->createDBSnapshot([
'DBInstanceIdentifier' => $dbIdentifier,
'DBSnapshotIdentifier' => $snapshotName,
]);
var_dump($result);
} catch (AwsException $e) {
echo $e->getMessage();
echo "\n";
}
```
+ Per i dettagli sull'API, consulta [Create DBSnapshot](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/CreateDBSnapshot) in *AWS SDK per PHP API Reference*.
### `DeleteDBInstance`
Il seguente esempio di codice mostra come utilizzare`DeleteDBInstance`.
**SDK per PHP**
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/php/example_code/rds#code-examples).
```
require __DIR__ . '/vendor/autoload.php';
use Aws\Exception\AwsException;
//Create an RDSClient
$rdsClient = new Aws\Rds\RdsClient([
'region' => 'us-east-1'
]);
$dbIdentifier = '<<{{db-identifier}}>>';
try {
$result = $rdsClient->deleteDBInstance([
'DBInstanceIdentifier' => $dbIdentifier,
]);
var_dump($result);
} catch (AwsException $e) {
echo $e->getMessage();
echo "\n";
}
```
+ Per i dettagli sull'API, consulta [Delete DBInstance](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/DeleteDBInstance) in *AWS SDK per PHP API Reference*.
### `DescribeDBInstances`
Il seguente esempio di codice mostra come utilizzare`DescribeDBInstances`.
**SDK per PHP**
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/php/example_code/rds#code-examples).
```
require __DIR__ . '/vendor/autoload.php';
use Aws\Exception\AwsException;
//Create an RDSClient
$rdsClient = new Aws\Rds\RdsClient([
'region' => 'us-east-2'
]);
try {
$result = $rdsClient->describeDBInstances();
foreach ($result['DBInstances'] as $instance) {
print('DB Identifier: ' . $instance['DBInstanceIdentifier']);
print('
Endpoint: ' . $instance['Endpoint']["Address"]
. ':' . $instance['Endpoint']["Port"]);
print('
Current Status: ' . $instance["DBInstanceStatus"]);
print('
');
}
print(" Raw Result ");
var_dump($result);
} catch (AwsException $e) {
echo $e->getMessage();
echo "\n";
}
```
+ Per i dettagli sull'API, consulta [Descrivi DBInstances](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/DescribeDBInstances) in *AWS SDK per PHP API Reference*.
## Scenari
### Creazione di un tracciatore di elementi di lavoro di Aurora Serverless
L’esempio di codice seguente mostra come creare un’applicazione web che traccia gli elementi di lavoro in database Amazon Aurora serverless e utilizza Amazon Simple Email Service (Amazon SES) per inviare report.
**SDK per PHP**
Mostra come utilizzare per AWS SDK per PHP creare un'applicazione Web che tenga traccia degli elementi di lavoro in un database Amazon RDS e invii report tramite e-mail utilizzando Amazon Simple Email Service (Amazon SES). Questo esempio utilizza un front-end creato con React.js per interagire con un backend RESTful PHP.
+ Integra un'applicazione web React.js con AWS i servizi.
+ Elenca, aggiungi, aggiorna ed elimina gli elementi in una tabella Amazon RDS.
+ Invia un report per e-mail degli articoli di lavoro filtrati tramite Amazon SES.
+ Distribuisci e gestisci risorse di esempio con lo AWS CloudFormation script incluso.
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/php/cross_service/aurora_item_tracker).
**Servizi utilizzati in questo esempio**
+ Aurora
+ Amazon RDS
+ Servizi di dati di Amazon RDS
+ Amazon SES
## Esempi serverless
### Connessione a un database Amazon RDS in una funzione Lambda
L’esempio di codice seguente mostra come implementare una funzione Lambda che si connette a un database RDS. La funzione effettua una semplice richiesta al database e restituisce il risultato.
**SDK per PHP**
C'è altro su GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Connessione a un database Amazon RDS in una funzione Lambda tramite PHP.
```
logger = $logger;
}
private function getAuthToken(): string {
// Define connection authentication parameters
$dbConnection = [
'hostname' => getenv('DB_HOSTNAME'),
'port' => getenv('DB_PORT'),
'username' => getenv('DB_USERNAME'),
'region' => getenv('AWS_REGION'),
];
// Create RDS AuthTokenGenerator object
$generator = new AuthTokenGenerator(CredentialProvider::defaultProvider());
// Request authorization token from RDS, specifying the username
return $generator->createToken(
$dbConnection['hostname'] . ':' . $dbConnection['port'],
$dbConnection['region'],
$dbConnection['username']
);
}
private function getQueryResults() {
// Obtain auth token
$token = $this->getAuthToken();
// Define connection configuration
$connectionConfig = [
'host' => getenv('DB_HOSTNAME'),
'user' => getenv('DB_USERNAME'),
'password' => $token,
'database' => getenv('DB_NAME'),
];
// Create the connection to the DB
$conn = new PDO(
"mysql:host={$connectionConfig['host']};dbname={$connectionConfig['database']}",
$connectionConfig['user'],
$connectionConfig['password'],
[
PDO::MYSQL_ATTR_SSL_CA => '/path/to/rds-ca-2019-root.pem',
PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true,
]
);
// Obtain the result of the query
$stmt = $conn->prepare('SELECT ?+? AS sum');
$stmt->execute([3, 2]);
return $stmt->fetch(PDO::FETCH_ASSOC);
}
/**
* @param mixed $event
* @param Context $context
* @return array
*/
public function handle(mixed $event, Context $context): array
{
$this->logger->info("Processing query");
// Execute database flow
$result = $this->getQueryResults();
return [
'sum' => $result['sum']
];
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
# Esempi per il servizio dati di Amazon RDS con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP con Amazon RDS Data Service.
*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, dove è possibile trovare le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Scenari](#scenarios)
## Scenari
### Creazione di un tracciatore di elementi di lavoro di Aurora Serverless
L’esempio di codice seguente mostra come creare un’applicazione web che traccia gli elementi di lavoro in database Amazon Aurora serverless e utilizza Amazon Simple Email Service (Amazon SES) per inviare report.
**SDK per PHP**
Mostra come utilizzare per AWS SDK per PHP creare un'applicazione Web che tenga traccia degli elementi di lavoro in un database Amazon RDS e invii report tramite e-mail utilizzando Amazon Simple Email Service (Amazon SES). Questo esempio utilizza un front-end creato con React.js per interagire con un backend RESTful PHP.
+ Integra un'applicazione web React.js con AWS i servizi.
+ Elenca, aggiungi, aggiorna ed elimina gli elementi in una tabella Amazon RDS.
+ Invia un report per e-mail degli articoli di lavoro filtrati tramite Amazon SES.
+ Distribuisci e gestisci risorse di esempio con lo AWS CloudFormation script incluso.
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/php/cross_service/aurora_item_tracker).
**Servizi utilizzati in questo esempio**
+ Aurora
+ Amazon RDS
+ Servizi di dati di Amazon RDS
+ Amazon SES
# Esempi per Amazon Rekognition con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando Amazon AWS SDK per PHP Rekognition.
*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, dove è possibile trovare le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Scenari](#scenarios)
## Scenari
### Creazione di un’applicazione serverless per gestire foto
L’esempio di codice seguente mostra come creare un’applicazione serverless che consente agli utenti di gestire le foto mediante etichette.
**SDK per PHP**
Mostra come sviluppare un’applicazione per la gestione delle risorse fotografiche che rileva le etichette nelle immagini utilizzando Amazon Rekognition e le archivia per recuperarle in seguito.
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/php/applications/photo_asset_manager)
Per approfondire l’origine di questo esempio, consulta il post su [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servizi utilizzati in questo esempio**
+ Gateway API
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Simple Storage Service (Amazon S3)
+ Amazon SNS
# Esempi per Amazon S3 con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando Amazon S3. AWS SDK per PHP
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
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**
+ [Nozioni di base](#get_started)
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
+ [Scenari](#scenarios)
+ [Esempi serverless](#serverless_examples)
## Nozioni di base
### Hello Amazon S3
Il seguente esempio di codice mostra come iniziare a usare Amazon S3.
**SDK per PHP**
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/php/example_code/s3#code-examples).
```
use Aws\S3\S3Client;
$client = new S3Client(['region' => 'us-west-2']);
$results = $client->listBuckets();
var_dump($results);
```
+ Per i dettagli sull'API, [ListBuckets](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/ListBuckets)consulta *AWS SDK per PHP API Reference*.
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come:
+ Crea un bucket e carica un file in tale bucket.
+ Scaricare un oggetto da un bucket.
+ Copiare un oggetto in una sottocartella in un bucket.
+ Elencare gli oggetti in un bucket.
+ Elimina il bucket e tutti gli oggetti in esso contenuti.
**SDK per PHP**
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/php/example_code/s3#code-examples).
```
echo("\n");
echo("--------------------------------------\n");
print("Welcome to the Amazon S3 getting started demo using PHP!\n");
echo("--------------------------------------\n");
$region = 'us-west-2';
$this->s3client = new S3Client([
'region' => $region,
]);
/* Inline declaration example
$s3client = new Aws\S3\S3Client(['region' => 'us-west-2']);
*/
$this->bucketName = "amzn-s3-demo-bucket-" . uniqid();
try {
$this->s3client->createBucket([
'Bucket' => $this->bucketName,
'CreateBucketConfiguration' => ['LocationConstraint' => $region],
]);
echo "Created bucket named: $this->bucketName \n";
} catch (Exception $exception) {
echo "Failed to create bucket $this->bucketName with error: " . $exception->getMessage();
exit("Please fix error with bucket creation before continuing.");
}
$fileName = __DIR__ . "/local-file-" . uniqid();
try {
$this->s3client->putObject([
'Bucket' => $this->bucketName,
'Key' => $fileName,
'SourceFile' => __DIR__ . '/testfile.txt'
]);
echo "Uploaded $fileName to $this->bucketName.\n";
} catch (Exception $exception) {
echo "Failed to upload $fileName with error: " . $exception->getMessage();
exit("Please fix error with file upload before continuing.");
}
try {
$file = $this->s3client->getObject([
'Bucket' => $this->bucketName,
'Key' => $fileName,
]);
$body = $file->get('Body');
$body->rewind();
echo "Downloaded the file and it begins with: {$body->read(26)}.\n";
} catch (Exception $exception) {
echo "Failed to download $fileName from $this->bucketName with error: " . $exception->getMessage();
exit("Please fix error with file downloading before continuing.");
}
try {
$folder = "copied-folder";
$this->s3client->copyObject([
'Bucket' => $this->bucketName,
'CopySource' => "$this->bucketName/$fileName",
'Key' => "$folder/$fileName-copy",
]);
echo "Copied $fileName to $folder/$fileName-copy.\n";
} catch (Exception $exception) {
echo "Failed to copy $fileName with error: " . $exception->getMessage();
exit("Please fix error with object copying before continuing.");
}
try {
$contents = $this->s3client->listObjectsV2([
'Bucket' => $this->bucketName,
]);
echo "The contents of your bucket are: \n";
foreach ($contents['Contents'] as $content) {
echo $content['Key'] . "\n";
}
} catch (Exception $exception) {
echo "Failed to list objects in $this->bucketName with error: " . $exception->getMessage();
exit("Please fix error with listing objects before continuing.");
}
try {
$objects = [];
foreach ($contents['Contents'] as $content) {
$objects[] = [
'Key' => $content['Key'],
];
}
$this->s3client->deleteObjects([
'Bucket' => $this->bucketName,
'Delete' => [
'Objects' => $objects,
],
]);
$check = $this->s3client->listObjectsV2([
'Bucket' => $this->bucketName,
]);
if (isset($check['Contents']) && count($check['Contents']) > 0) {
throw new Exception("Bucket wasn't empty.");
}
echo "Deleted all objects and folders from $this->bucketName.\n";
} catch (Exception $exception) {
echo "Failed to delete $fileName from $this->bucketName with error: " . $exception->getMessage();
exit("Please fix error with object deletion before continuing.");
}
try {
$this->s3client->deleteBucket([
'Bucket' => $this->bucketName,
]);
echo "Deleted bucket $this->bucketName.\n";
} catch (Exception $exception) {
echo "Failed to delete $this->bucketName with error: " . $exception->getMessage();
exit("Please fix error with bucket deletion before continuing.");
}
echo "Successfully ran the Amazon S3 with PHP demo.\n";
```
+ Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per PHP *.
+ [CopyObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/CopyObject)
+ [CreateBucket](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/CreateBucket)
+ [DeleteBucket](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteBucket)
+ [DeleteObjects](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteObjects)
+ [GetObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/GetObject)
+ [ListObjectsV2](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/ListObjectsV2)
+ [PutObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/PutObject)
## Azioni
### `CopyObject`
Il seguente esempio di codice mostra come usare`CopyObject`.
**SDK per PHP**
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/php/example_code/s3#code-examples).
Copia semplice di un oggetto.
```
$s3client = new Aws\S3\S3Client(['region' => 'us-west-2']);
try {
$folder = "copied-folder";
$this->s3client->copyObject([
'Bucket' => $this->bucketName,
'CopySource' => "$this->bucketName/$fileName",
'Key' => "$folder/$fileName-copy",
]);
echo "Copied $fileName to $folder/$fileName-copy.\n";
} catch (Exception $exception) {
echo "Failed to copy $fileName with error: " . $exception->getMessage();
exit("Please fix error with object copying before continuing.");
}
```
+ Per i dettagli sull'API, [CopyObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/CopyObject)consulta *AWS SDK per PHP API Reference*.
### `CreateBucket`
Il seguente esempio di codice mostra come utilizzare`CreateBucket`.
**SDK per PHP**
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/php/example_code/s3#code-examples).
Creare un bucket.
```
$s3client = new Aws\S3\S3Client(['region' => 'us-west-2']);
try {
$this->s3client->createBucket([
'Bucket' => $this->bucketName,
'CreateBucketConfiguration' => ['LocationConstraint' => $region],
]);
echo "Created bucket named: $this->bucketName \n";
} catch (Exception $exception) {
echo "Failed to create bucket $this->bucketName with error: " . $exception->getMessage();
exit("Please fix error with bucket creation before continuing.");
}
```
+ Per i dettagli sull'API, [CreateBucket](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/CreateBucket)consulta *AWS SDK per PHP API Reference*.
### `DeleteBucket`
Il seguente esempio di codice mostra come utilizzare`DeleteBucket`.
**SDK per PHP**
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/php/example_code/s3#code-examples).
Elimina un bucket vuoto.
```
$s3client = new Aws\S3\S3Client(['region' => 'us-west-2']);
try {
$this->s3client->deleteBucket([
'Bucket' => $this->bucketName,
]);
echo "Deleted bucket $this->bucketName.\n";
} catch (Exception $exception) {
echo "Failed to delete $this->bucketName with error: " . $exception->getMessage();
exit("Please fix error with bucket deletion before continuing.");
}
```
+ Per i dettagli sull'API, [DeleteBucket](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteBucket)consulta *AWS SDK per PHP API Reference*.
### `DeleteObject`
Il seguente esempio di codice mostra come utilizzare`DeleteObject`.
**SDK per PHP**
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/php/example_code/s3#code-examples).
```
public function deleteObject(string $bucketName, string $fileName, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName, 'Key' => $fileName], $args);
try {
$this->client->deleteObject($parameters);
if ($this->verbose) {
echo "Deleted the object named: $fileName from $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to delete $fileName from $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with object deletion before continuing.";
}
throw $exception;
}
}
```
+ Per i dettagli sull'API, [DeleteObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteObject)consulta *AWS SDK per PHP API Reference*.
### `DeleteObjects`
Il seguente esempio di codice mostra come utilizzare`DeleteObjects`.
**SDK per PHP**
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/php/example_code/s3#code-examples).
Elimina un set di oggetti da un elenco di chiavi.
```
$s3client = new Aws\S3\S3Client(['region' => 'us-west-2']);
try {
$objects = [];
foreach ($contents['Contents'] as $content) {
$objects[] = [
'Key' => $content['Key'],
];
}
$this->s3client->deleteObjects([
'Bucket' => $this->bucketName,
'Delete' => [
'Objects' => $objects,
],
]);
$check = $this->s3client->listObjectsV2([
'Bucket' => $this->bucketName,
]);
if (isset($check['Contents']) && count($check['Contents']) > 0) {
throw new Exception("Bucket wasn't empty.");
}
echo "Deleted all objects and folders from $this->bucketName.\n";
} catch (Exception $exception) {
echo "Failed to delete $fileName from $this->bucketName with error: " . $exception->getMessage();
exit("Please fix error with object deletion before continuing.");
}
```
+ Per i dettagli sull'API, [DeleteObjects](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteObjects)consulta *AWS SDK per PHP API Reference*.
### `GetObject`
Il seguente esempio di codice mostra come utilizzare`GetObject`.
**SDK per PHP**
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/php/example_code/s3#code-examples).
Recupera un oggetto.
```
$s3client = new Aws\S3\S3Client(['region' => 'us-west-2']);
try {
$file = $this->s3client->getObject([
'Bucket' => $this->bucketName,
'Key' => $fileName,
]);
$body = $file->get('Body');
$body->rewind();
echo "Downloaded the file and it begins with: {$body->read(26)}.\n";
} catch (Exception $exception) {
echo "Failed to download $fileName from $this->bucketName with error: " . $exception->getMessage();
exit("Please fix error with file downloading before continuing.");
}
```
+ Per i dettagli sull'API, [GetObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/GetObject)consulta *AWS SDK per PHP API Reference*.
### `ListObjectsV2`
Il seguente esempio di codice mostra come utilizzare`ListObjectsV2`.
**SDK per PHP**
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/php/example_code/s3#code-examples).
Elenca gli oggetti in un bucket.
```
$s3client = new Aws\S3\S3Client(['region' => 'us-west-2']);
try {
$contents = $this->s3client->listObjectsV2([
'Bucket' => $this->bucketName,
]);
echo "The contents of your bucket are: \n";
foreach ($contents['Contents'] as $content) {
echo $content['Key'] . "\n";
}
} catch (Exception $exception) {
echo "Failed to list objects in $this->bucketName with error: " . $exception->getMessage();
exit("Please fix error with listing objects before continuing.");
}
```
+ Per i dettagli sull'API, consulta la [ListObjectsversione V2](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/ListObjectsV2) in *AWS SDK per PHP API Reference.*
### `PutObject`
Il seguente esempio di codice mostra come utilizzare`PutObject`.
**SDK per PHP**
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/php/example_code/s3#code-examples).
Carica un oggetto in un bucket.
```
$s3client = new Aws\S3\S3Client(['region' => 'us-west-2']);
$fileName = __DIR__ . "/local-file-" . uniqid();
try {
$this->s3client->putObject([
'Bucket' => $this->bucketName,
'Key' => $fileName,
'SourceFile' => __DIR__ . '/testfile.txt'
]);
echo "Uploaded $fileName to $this->bucketName.\n";
} catch (Exception $exception) {
echo "Failed to upload $fileName with error: " . $exception->getMessage();
exit("Please fix error with file upload before continuing.");
}
```
+ Per i dettagli sull'API, [PutObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/PutObject)consulta *AWS SDK per PHP API Reference*.
## Scenari
### Creazione di un URL prefirmato
L’esempio di codice seguente mostra come creare un URL prefirmato per Amazon S3 e caricare un oggetto.
**SDK per PHP**
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/php/example_code/s3#code-examples).
```
namespace S3;
use Aws\Exception\AwsException;
use AwsUtilities\PrintableLineBreak;
use AwsUtilities\TestableReadline;
use DateTime;
require 'vendor/autoload.php';
class PresignedURL
{
use PrintableLineBreak;
use TestableReadline;
public function run()
{
$s3Service = new S3Service();
$expiration = new DateTime("+20 minutes");
$linebreak = $this->getLineBreak();
echo $linebreak;
echo ("Welcome to the Amazon S3 presigned URL demo.\n");
echo $linebreak;
$bucket = $this->testable_readline("First, please enter the name of the S3 bucket to use: ");
$key = $this->testable_readline("Next, provide the key of an object in the given bucket: ");
echo $linebreak;
$command = $s3Service->getClient()->getCommand('GetObject', [
'Bucket' => $bucket,
'Key' => $key,
]);
try {
$preSignedUrl = $s3Service->preSignedUrl($command, $expiration);
echo "Your preSignedUrl is \n$preSignedUrl\nand will be good for the next 20 minutes.\n";
echo $linebreak;
echo "Thanks for trying the Amazon S3 presigned URL demo.\n";
} catch (AwsException $exception) {
echo $linebreak;
echo "Something went wrong: $exception";
die();
}
}
}
$runner = new PresignedURL();
$runner->run();
namespace S3;
use Aws\CommandInterface;
use Aws\Exception\AwsException;
use Aws\Result;
use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
use AwsUtilities\AWSServiceClass;
use DateTimeInterface;
class S3Service extends AWSServiceClass
{
protected S3Client $client;
protected bool $verbose;
public function __construct(S3Client $client = null, $verbose = false)
{
if ($client) {
$this->client = $client;
} else {
$this->client = new S3Client([
'version' => 'latest',
'region' => 'us-west-2',
]);
}
$this->verbose = $verbose;
}
public function setVerbose($verbose)
{
$this->verbose = $verbose;
}
public function isVerbose(): bool
{
return $this->verbose;
}
public function getClient(): S3Client
{
return $this->client;
}
public function setClient(S3Client $client)
{
$this->client = $client;
}
public function emptyAndDeleteBucket($bucketName, array $args = [])
{
try {
$objects = $this->listAllObjects($bucketName, $args);
$this->deleteObjects($bucketName, $objects, $args);
if ($this->verbose) {
echo "Deleted all objects and folders from $bucketName.\n";
}
$this->deleteBucket($bucketName, $args);
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to delete $bucketName with error: {$exception->getMessage()}\n";
echo "\nPlease fix error with bucket deletion before continuing.\n";
}
throw $exception;
}
}
public function createBucket(string $bucketName, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName], $args);
try {
$this->client->createBucket($parameters);
if ($this->verbose) {
echo "Created the bucket named: $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to create $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with bucket creation before continuing.";
}
throw $exception;
}
}
public function putObject(string $bucketName, string $key, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName, 'Key' => $key], $args);
try {
$this->client->putObject($parameters);
if ($this->verbose) {
echo "Uploaded the object named: $key to the bucket named: $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to create $key in $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with object uploading before continuing.";
}
throw $exception;
}
}
public function getObject(string $bucketName, string $key, array $args = []): Result
{
$parameters = array_merge(['Bucket' => $bucketName, 'Key' => $key], $args);
try {
$object = $this->client->getObject($parameters);
if ($this->verbose) {
echo "Downloaded the object named: $key to the bucket named: $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to download $key from $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with object downloading before continuing.";
}
throw $exception;
}
return $object;
}
public function copyObject($bucketName, $key, $copySource, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName, 'Key' => $key, "CopySource" => $copySource], $args);
try {
$this->client->copyObject($parameters);
if ($this->verbose) {
echo "Copied the object from: $copySource in $bucketName to: $key.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to copy $copySource in $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with object copying before continuing.";
}
throw $exception;
}
}
public function listObjects(string $bucketName, $start = 0, $max = 1000, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName, 'Marker' => $start, "MaxKeys" => $max], $args);
try {
$objects = $this->client->listObjectsV2($parameters);
if ($this->verbose) {
echo "Retrieved the list of objects from: $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to retrieve the objects from $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with list objects before continuing.";
}
throw $exception;
}
return $objects;
}
public function listAllObjects($bucketName, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName], $args);
$contents = [];
$paginator = $this->client->getPaginator("ListObjectsV2", $parameters);
foreach ($paginator as $result) {
if($result['KeyCount'] == 0){
break;
}
foreach ($result['Contents'] as $object) {
$contents[] = $object;
}
}
return $contents;
}
public function deleteObjects(string $bucketName, array $objects, array $args = [])
{
$listOfObjects = array_map(
function ($object) {
return ['Key' => $object];
},
array_column($objects, 'Key')
);
if(!$listOfObjects){
return;
}
$parameters = array_merge(['Bucket' => $bucketName, 'Delete' => ['Objects' => $listOfObjects]], $args);
try {
$this->client->deleteObjects($parameters);
if ($this->verbose) {
echo "Deleted the list of objects from: $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to delete the list of objects from $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with object deletion before continuing.";
}
throw $exception;
}
}
public function deleteBucket(string $bucketName, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName], $args);
try {
$this->client->deleteBucket($parameters);
if ($this->verbose) {
echo "Deleted the bucket named: $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to delete $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with bucket deletion before continuing.";
}
throw $exception;
}
}
public function deleteObject(string $bucketName, string $fileName, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName, 'Key' => $fileName], $args);
try {
$this->client->deleteObject($parameters);
if ($this->verbose) {
echo "Deleted the object named: $fileName from $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to delete $fileName from $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with object deletion before continuing.";
}
throw $exception;
}
}
public function listBuckets(array $args = [])
{
try {
$buckets = $this->client->listBuckets($args);
if ($this->verbose) {
echo "Retrieved all " . count($buckets) . "\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to retrieve bucket list with error: {$exception->getMessage()}\n";
echo "Please fix error with bucket lists before continuing.";
}
throw $exception;
}
return $buckets;
}
public function preSignedUrl(CommandInterface $command, DateTimeInterface|int|string $expires, array $options = [])
{
$request = $this->client->createPresignedRequest($command, $expires, $options);
try {
$presignedUrl = (string)$request->getUri();
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to create a presigned url: {$exception->getMessage()}\n";
echo "Please fix error with presigned urls before continuing.";
}
throw $exception;
}
return $presignedUrl;
}
public function createSession(string $bucketName)
{
try{
$result = $this->client->createSession([
'Bucket' => $bucketName,
]);
return $result;
}catch(S3Exception $caught){
if($caught->getAwsErrorType() == "NoSuchBucket"){
echo "The specified bucket does not exist.";
}
throw $caught;
}
}
}
```
### Creazione di un’applicazione serverless per gestire foto
L’esempio di codice seguente mostra come creare un’applicazione serverless che consente agli utenti di gestire le foto mediante etichette.
**SDK per PHP**
Mostra come sviluppare un’applicazione per la gestione delle risorse fotografiche che rileva le etichette nelle immagini utilizzando Amazon Rekognition e le archivia per recuperarle in seguito.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Per approfondire l’origine di questo esempio, consulta il post su [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servizi utilizzati in questo esempio**
+ Gateway API
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Simple Storage Service (Amazon S3)
+ Amazon SNS
## Esempi serverless
### Invocazione di una funzione Lambda da un trigger Amazon S3
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dal caricamento di un oggetto in un bucket S3. La funzione recupera il nome del bucket S3 e la chiave dell’oggetto dal parametro evento e chiama l’API Amazon S3 per recuperare e registrare il tipo di contenuto dell’oggetto.
**SDK per PHP**
C'è altro su GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Utilizzo di un evento S3 con Lambda tramite PHP.
```
logger = $logger;
}
public function handleS3(S3Event $event, Context $context) : void
{
$this->logger->info("Processing S3 records");
// Get the object from the event and show its content type
$records = $event->getRecords();
foreach ($records as $record)
{
$bucket = $record->getBucket()->getName();
$key = urldecode($record->getObject()->getKey());
try {
$fileSize = urldecode($record->getObject()->getSize());
echo "File Size: " . $fileSize . "\n";
// TODO: Implement your custom processing logic here
} catch (Exception $e) {
echo $e->getMessage() . "\n";
echo 'Error getting object ' . $key . ' from bucket ' . $bucket . '. Make sure they exist and your bucket is in the same region as this function.' . "\n";
throw $e;
}
}
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
# Esempi per bucket di directory S3 con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP with S3 Directory Buckets.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
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**
+ [Nozioni di base](#basics)
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come:
+ Configurare un VPC e un endpoint VPC.
+ Configurare policy, ruoli e utente da utilizzare con i bucket di directory S3 e la classe di archiviazione S3 Express One Zone.
+ Creare due client S3.
+ Creare due bucket.
+ Creare un oggetto e copiarlo.
+ Descrivere la differenza di prestazioni.
+ Popolare i bucket per mostrare la differenza lessicografica.
+ Richiedere all’utente di verificare se eseguire o meno la pulizia delle risorse.
**SDK per PHP**
C'è di più 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/php/example_code/s3/express#code-examples).
Esegue uno scenario che descrive le nozioni di base relative ai bucket di directory Amazon S3 e S3 Express One Zone.
```
echo "\n";
echo "--------------------------------------\n";
echo "Welcome to the Amazon S3 Express Basics demo using PHP!\n";
echo "--------------------------------------\n";
// Change these both of these values to use a different region/availability zone.
$region = "us-west-2";
$az = "usw2-az1";
$this->s3Service = new S3Service(new S3Client(['region' => $region]));
$this->iamService = new IAMService(new IamClient(['region' => $region]));
$uuid = uniqid();
echo <<ec2Service = new EC2Service(new Ec2Client(['region' => $region]));
$cidr = "10.0.0.0/16";
$vpc = $this->ec2Service->createVpc($cidr);
$this->resources['vpcId'] = $vpc['VpcId'];
$this->ec2Service->waitForVpcAvailable($vpc['VpcId']);
$routeTable = $this->ec2Service->describeRouteTables([], [
[
'Name' => "vpc-id",
'Values' => [$vpc['VpcId']],
],
]);
$serviceName = "com.amazonaws." . $this->ec2Service->getRegion() . ".s3express";
$vpcEndpoint = $this->ec2Service->createVpcEndpoint($serviceName, $vpc['VpcId'], [$routeTable[0]]);
$this->resources['vpcEndpointId'] = $vpcEndpoint['VpcEndpointId'];
}else{
echo "Skipping the VPC setup. Don't forget to use this in production!\n";
}
// 2. Policies, user, and roles with CDK.
echo "\n";
echo "2. Policies, users, and roles with CDK.\n";
echo "Now, we'll set up some policies, roles, and a user. This user will only have permissions to do S3 Express One Zone actions.\n";
pressEnter();
$this->cloudFormationClient = new CloudFormationClient([]);
$stackName = "cfn-stack-s3-express-basics-" . uniqid();
$file = file_get_contents(__DIR__ . "/../../../../resources/cfn/s3_express_basics/s3_express_template.yml");
$result = $this->cloudFormationClient->createStack([
'StackName' => $stackName,
'TemplateBody' => $file,
'Capabilities' => ['CAPABILITY_IAM'],
]);
$waiter = $this->cloudFormationClient->getWaiter("StackCreateComplete", ['StackName' => $stackName]);
try {
$waiter->promise()->wait();
}catch(CloudFormationException $caught){
echo "Error waiting for the CloudFormation stack to create: {$caught->getAwsErrorMessage()}\n";
throw $caught;
}
$this->resources['stackName'] = $stackName;
$stackInfo = $this->cloudFormationClient->describeStacks([
'StackName' => $result['StackId'],
]);
$expressUserName = "";
$regularUserName = "";
foreach($stackInfo['Stacks'][0]['Outputs'] as $output) {
if ($output['OutputKey'] == "RegularUser") {
$regularUserName = $output['OutputValue'];
}
if ($output['OutputKey'] == "ExpressUser") {
$expressUserName = $output['OutputValue'];
}
}
$regularKey = $this->iamService->createAccessKey($regularUserName);
$regularCredentials = new Credentials($regularKey['AccessKeyId'], $regularKey['SecretAccessKey']);
$expressKey = $this->iamService->createAccessKey($expressUserName);
$expressCredentials = new Credentials($expressKey['AccessKeyId'], $expressKey['SecretAccessKey']);
// 3. Create an additional client using the credentials with S3 Express permissions.
echo "\n";
echo "3. Create an additional client using the credentials with S3 Express permissions.\n";
echo "This client is created with the credentials associated with the user account with the S3 Express policy attached, so it can perform S3 Express operations.\n";
pressEnter();
$s3RegularClient = new S3Client([
'Region' => $region,
'Credentials' => $regularCredentials,
]);
$s3RegularService = new S3Service($s3RegularClient);
$s3ExpressClient = new S3Client([
'Region' => $region,
'Credentials' => $expressCredentials,
]);
$s3ExpressService = new S3Service($s3ExpressClient);
echo "All the roles and policies were created an attached to the user. Then, a new S3 Client and Service were created using that user's credentials.\n";
echo "We can now use this client to make calls to S3 Express operations. Keeping permissions in mind (and adhering to least-privilege) is crucial to S3 Express.\n";
pressEnter();
// 4. Create two buckets.
echo "\n";
echo "3. Create two buckets.\n";
echo "Now we will create a Directory bucket, which is the linchpin of the S3 Express One Zone service.\n";
echo "Directory buckets behave in different ways from regular S3 buckets, which we will explore here.\n";
echo "We'll also create a normal bucket, put an object into the normal bucket, and copy it over to the Directory bucket.\n";
pressEnter();
// Create a directory bucket. These are different from normal S3 buckets in subtle ways.
$directoryBucketName = "s3-express-demo-directory-bucket-$uuid--$az--x-s3";
echo "Now, let's create the actual Directory bucket, as well as a regular bucket.\n";
pressEnter();
$s3ExpressService->createBucket($directoryBucketName, [
'CreateBucketConfiguration' => [
'Bucket' => [
'Type' => "Directory", // This is what causes S3 to create a Directory bucket as opposed to a normal bucket.
'DataRedundancy' => "SingleAvailabilityZone",
],
'Location' => [
'Name' => $az,
'Type' => "AvailabilityZone",
],
],
]);
$this->resources['directoryBucketName'] = $directoryBucketName;
// Create a normal bucket.
$normalBucketName = "normal-bucket-$uuid";
$s3RegularService->createBucket($normalBucketName);
$this->resources['normalBucketName'] = $normalBucketName;
echo "Great! Both buckets were created.\n";
pressEnter();
// 5. Create an object and copy it over.
echo "\n";
echo "5. Create an object and copy it over.\n";
echo "We'll create a basic object consisting of some text and upload it to the normal bucket.\n";
echo "Next, we'll copy the object into the Directory bucket using the regular client.\n";
echo "This works fine, because Copy operations are not restricted for Directory buckets.\n";
pressEnter();
$objectKey = "basic-text-object";
$s3RegularService->putObject($normalBucketName, $objectKey, $args = ['Body' => "Look Ma, I'm a bucket!"]);
$this->resources['objectKey'] = $objectKey;
// Create a session to access the directory bucket. The SDK Client will automatically refresh this as needed.
$s3ExpressService->createSession($directoryBucketName);
$s3ExpressService->copyObject($directoryBucketName, $objectKey, "$normalBucketName/$objectKey");
echo "It worked! It's important to remember the user permissions when interacting with Directory buckets.\n";
echo "Instead of validating permissions on every call as normal buckets do, Directory buckets utilize the user credentials and session token to validate.\n";
echo "This allows for much faster connection speeds on every call. For single calls, this is low, but for many concurrent calls, this adds up to a lot of time saved.\n";
pressEnter();
// 6. Demonstrate performance difference.
echo "\n";
echo "6. Demonstrate performance difference.\n";
$downloads = 1000;
echo "Now, let's do a performance test. We'll download the same object from each bucket $downloads times and compare the total time needed. Note: the performance difference will be much more pronounced if this example is run in an EC2 instance in the same AZ as the bucket.\n";
$downloadChoice = testable_readline("If you would like to download each object $downloads times, press enter. Otherwise, enter a custom amount and press enter.");
if($downloadChoice && is_numeric($downloadChoice) && $downloadChoice < 1000000){ // A million is enough. I promise.
$downloads = $downloadChoice;
}
// Download the object $downloads times from each bucket and time it to demonstrate the speed difference.
$directoryStartTime = hrtime(true);
for($i = 0; $i < $downloads; ++$i){
$s3ExpressService->getObject($directoryBucketName, $objectKey);
}
$directoryEndTime = hrtime(true);
$directoryTimeDiff = $directoryEndTime - $directoryStartTime;
$normalStartTime = hrtime(true);
for($i = 0; $i < $downloads; ++$i){
$s3RegularService->getObject($normalBucketName, $objectKey);
}
$normalEndTime = hrtime(true);
$normalTimeDiff = $normalEndTime - $normalStartTime;
echo "The directory bucket took $directoryTimeDiff nanoseconds, while the normal bucket took $normalTimeDiff.\n";
echo "That's a difference of " . ($normalTimeDiff - $directoryTimeDiff) . " nanoseconds, or " . (($normalTimeDiff - $directoryTimeDiff)/1000000000) . " seconds.\n";
pressEnter();
// 7. Populate the buckets to show the lexicographical difference.
echo "\n";
echo "7. Populate the buckets to show the lexicographical difference.\n";
echo "Now let's explore how Directory buckets store objects in a different manner to regular buckets.\n";
echo "The key is in the name \"Directory!\"\n";
echo "Where regular buckets store their key/value pairs in a flat manner, Directory buckets use actual directories/folders.\n";
echo "This allows for more rapid indexing, traversing, and therefore retrieval times!\n";
echo "The more segmented your bucket is, with lots of directories, sub-directories, and objects, the more efficient it becomes.\n";
echo "This structural difference also causes ListObjects to behave differently, which can cause unexpected results.\n";
echo "Let's add a few more objects with layered directories as see how the output of ListObjects changes.\n";
pressEnter();
// Populate a few more files in each bucket so that we can use ListObjects and show the difference.
$otherObject = "other/$objectKey";
$altObject = "alt/$objectKey";
$otherAltObject = "other/alt/$objectKey";
$s3ExpressService->putObject($directoryBucketName, $otherObject);
$s3RegularService->putObject($normalBucketName, $otherObject);
$this->resources['otherObject'] = $otherObject;
$s3ExpressService->putObject($directoryBucketName, $altObject);
$s3RegularService->putObject($normalBucketName, $altObject);
$this->resources['altObject'] = $altObject;
$s3ExpressService->putObject($directoryBucketName, $otherAltObject);
$s3RegularService->putObject($normalBucketName, $otherAltObject);
$this->resources['otherAltObject'] = $otherAltObject;
$listDirectoryBucket = $s3ExpressService->listObjects($directoryBucketName);
$listNormalBucket = $s3RegularService->listObjects($normalBucketName);
// Directory bucket content
echo "Directory bucket content\n";
foreach($listDirectoryBucket['Contents'] as $result){
echo $result['Key'] . "\n";
}
// Normal bucket content
echo "\nNormal bucket content\n";
foreach($listNormalBucket['Contents'] as $result){
echo $result['Key'] . "\n";
}
echo "Notice how the normal bucket lists objects in lexicographical order, while the directory bucket does not. This is because the normal bucket considers the whole \"key\" to be the object identifies, while the directory bucket actually creates directories and uses the object \"key\" as a path to the object.\n";
pressEnter();
echo "\n";
echo "That's it for our tour of the basic operations for S3 Express One Zone.\n";
$cleanUp = testable_readline("Would you like to delete all the resources created during this demo? Enter Y/y to delete all the resources.");
if($cleanUp){
$this->cleanUp();
}
namespace S3;
use Aws\CommandInterface;
use Aws\Exception\AwsException;
use Aws\Result;
use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;
use AwsUtilities\AWSServiceClass;
use DateTimeInterface;
class S3Service extends AWSServiceClass
{
protected S3Client $client;
protected bool $verbose;
public function __construct(S3Client $client = null, $verbose = false)
{
if ($client) {
$this->client = $client;
} else {
$this->client = new S3Client([
'version' => 'latest',
'region' => 'us-west-2',
]);
}
$this->verbose = $verbose;
}
public function setVerbose($verbose)
{
$this->verbose = $verbose;
}
public function isVerbose(): bool
{
return $this->verbose;
}
public function getClient(): S3Client
{
return $this->client;
}
public function setClient(S3Client $client)
{
$this->client = $client;
}
public function emptyAndDeleteBucket($bucketName, array $args = [])
{
try {
$objects = $this->listAllObjects($bucketName, $args);
$this->deleteObjects($bucketName, $objects, $args);
if ($this->verbose) {
echo "Deleted all objects and folders from $bucketName.\n";
}
$this->deleteBucket($bucketName, $args);
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to delete $bucketName with error: {$exception->getMessage()}\n";
echo "\nPlease fix error with bucket deletion before continuing.\n";
}
throw $exception;
}
}
public function createBucket(string $bucketName, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName], $args);
try {
$this->client->createBucket($parameters);
if ($this->verbose) {
echo "Created the bucket named: $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to create $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with bucket creation before continuing.";
}
throw $exception;
}
}
public function putObject(string $bucketName, string $key, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName, 'Key' => $key], $args);
try {
$this->client->putObject($parameters);
if ($this->verbose) {
echo "Uploaded the object named: $key to the bucket named: $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to create $key in $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with object uploading before continuing.";
}
throw $exception;
}
}
public function getObject(string $bucketName, string $key, array $args = []): Result
{
$parameters = array_merge(['Bucket' => $bucketName, 'Key' => $key], $args);
try {
$object = $this->client->getObject($parameters);
if ($this->verbose) {
echo "Downloaded the object named: $key to the bucket named: $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to download $key from $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with object downloading before continuing.";
}
throw $exception;
}
return $object;
}
public function copyObject($bucketName, $key, $copySource, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName, 'Key' => $key, "CopySource" => $copySource], $args);
try {
$this->client->copyObject($parameters);
if ($this->verbose) {
echo "Copied the object from: $copySource in $bucketName to: $key.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to copy $copySource in $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with object copying before continuing.";
}
throw $exception;
}
}
public function listObjects(string $bucketName, $start = 0, $max = 1000, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName, 'Marker' => $start, "MaxKeys" => $max], $args);
try {
$objects = $this->client->listObjectsV2($parameters);
if ($this->verbose) {
echo "Retrieved the list of objects from: $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to retrieve the objects from $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with list objects before continuing.";
}
throw $exception;
}
return $objects;
}
public function listAllObjects($bucketName, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName], $args);
$contents = [];
$paginator = $this->client->getPaginator("ListObjectsV2", $parameters);
foreach ($paginator as $result) {
if($result['KeyCount'] == 0){
break;
}
foreach ($result['Contents'] as $object) {
$contents[] = $object;
}
}
return $contents;
}
public function deleteObjects(string $bucketName, array $objects, array $args = [])
{
$listOfObjects = array_map(
function ($object) {
return ['Key' => $object];
},
array_column($objects, 'Key')
);
if(!$listOfObjects){
return;
}
$parameters = array_merge(['Bucket' => $bucketName, 'Delete' => ['Objects' => $listOfObjects]], $args);
try {
$this->client->deleteObjects($parameters);
if ($this->verbose) {
echo "Deleted the list of objects from: $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to delete the list of objects from $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with object deletion before continuing.";
}
throw $exception;
}
}
public function deleteBucket(string $bucketName, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName], $args);
try {
$this->client->deleteBucket($parameters);
if ($this->verbose) {
echo "Deleted the bucket named: $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to delete $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with bucket deletion before continuing.";
}
throw $exception;
}
}
public function deleteObject(string $bucketName, string $fileName, array $args = [])
{
$parameters = array_merge(['Bucket' => $bucketName, 'Key' => $fileName], $args);
try {
$this->client->deleteObject($parameters);
if ($this->verbose) {
echo "Deleted the object named: $fileName from $bucketName.\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to delete $fileName from $bucketName with error: {$exception->getMessage()}\n";
echo "Please fix error with object deletion before continuing.";
}
throw $exception;
}
}
public function listBuckets(array $args = [])
{
try {
$buckets = $this->client->listBuckets($args);
if ($this->verbose) {
echo "Retrieved all " . count($buckets) . "\n";
}
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to retrieve bucket list with error: {$exception->getMessage()}\n";
echo "Please fix error with bucket lists before continuing.";
}
throw $exception;
}
return $buckets;
}
public function preSignedUrl(CommandInterface $command, DateTimeInterface|int|string $expires, array $options = [])
{
$request = $this->client->createPresignedRequest($command, $expires, $options);
try {
$presignedUrl = (string)$request->getUri();
} catch (AwsException $exception) {
if ($this->verbose) {
echo "Failed to create a presigned url: {$exception->getMessage()}\n";
echo "Please fix error with presigned urls before continuing.";
}
throw $exception;
}
return $presignedUrl;
}
public function createSession(string $bucketName)
{
try{
$result = $this->client->createSession([
'Bucket' => $bucketName,
]);
return $result;
}catch(S3Exception $caught){
if($caught->getAwsErrorType() == "NoSuchBucket"){
echo "The specified bucket does not exist.";
}
throw $caught;
}
}
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK per PHP *.
+ [CopyObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/CopyObject)
+ [CreateBucket](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/CreateBucket)
+ [DeleteBucket](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteBucket)
+ [DeleteObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteObject)
+ [GetObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/GetObject)
+ [ListObjects](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/ListObjects)
+ [PutObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/PutObject)
# Esempi per Amazon SES con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP con Amazon SES.
*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, dove è possibile trovare le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Scenari](#scenarios)
## Scenari
### Creazione di un tracciatore di elementi di lavoro di Aurora Serverless
L’esempio di codice seguente mostra come creare un’applicazione web che traccia gli elementi di lavoro in database Amazon Aurora serverless e utilizza Amazon Simple Email Service (Amazon SES) per inviare report.
**SDK per PHP**
Mostra come utilizzare per AWS SDK per PHP creare un'applicazione Web che tenga traccia degli elementi di lavoro in un database Amazon RDS e invii report tramite e-mail utilizzando Amazon Simple Email Service (Amazon SES). Questo esempio utilizza un front-end creato con React.js per interagire con un backend RESTful PHP.
+ Integra un'applicazione web React.js con AWS i servizi.
+ Elenca, aggiungi, aggiorna ed elimina gli elementi in una tabella Amazon RDS.
+ Invia un report per e-mail degli articoli di lavoro filtrati tramite Amazon SES.
+ Distribuisci e gestisci risorse di esempio con lo AWS CloudFormation script incluso.
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/php/cross_service/aurora_item_tracker).
**Servizi utilizzati in questo esempio**
+ Aurora
+ Amazon RDS
+ Servizi di dati di Amazon RDS
+ Amazon SES
# Esempi per Amazon SNS con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP con Amazon SNS.
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)
+ [Esempi serverless](#serverless_examples)
## Azioni
### `CheckIfPhoneNumberIsOptedOut`
Il seguente esempio di codice mostra come usare`CheckIfPhoneNumberIsOptedOut`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Indicates whether the phone number owner has opted out of receiving SMS messages from your AWS SNS account.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$phone = '+1XXX5550100';
try {
$result = $SnSclient->checkIfPhoneNumberIsOptedOut([
'phoneNumber' => $phone,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#check-if-a-phone-number-has-opted-out).
+ Per i dettagli sull'API, [CheckIfPhoneNumberIsOptedOut](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/CheckIfPhoneNumberIsOptedOut)consulta *AWS SDK per PHP API Reference*.
### `ConfirmSubscription`
Il seguente esempio di codice mostra come utilizzare`ConfirmSubscription`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Verifies an endpoint owner's intent to receive messages by
* validating the token sent to the endpoint by an earlier Subscribe action.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$subscription_token = 'arn:aws:sns:us-east-1:111122223333:MyTopic:123456-abcd-12ab-1234-12ba3dc1234a';
$topic = 'arn:aws:sns:us-east-1:111122223333:MyTopic';
try {
$result = $SnSclient->confirmSubscription([
'Token' => $subscription_token,
'TopicArn' => $topic,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per i dettagli sull'API, [ConfirmSubscription](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/ConfirmSubscription)consulta *AWS SDK per PHP API Reference*.
### `CreateTopic`
Il seguente esempio di codice mostra come utilizzare`CreateTopic`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Create a Simple Notification Service topics in your AWS account at the requested region.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$topicname = 'myTopic';
try {
$result = $SnSclient->createTopic([
'Name' => $topicname,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-managing-topics.html#create-a-topic).
+ Per i dettagli sull'API, [CreateTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/CreateTopic)consulta *AWS SDK per PHP API Reference*.
### `DeleteTopic`
Il seguente esempio di codice mostra come utilizzare`DeleteTopic`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Deletes an SNS topic and all its subscriptions.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$topic = 'arn:aws:sns:us-east-1:111122223333:MyTopic';
try {
$result = $SnSclient->deleteTopic([
'TopicArn' => $topic,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per i dettagli sull'API, [DeleteTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/DeleteTopic)consulta *AWS SDK per PHP API Reference*.
### `GetSMSAttributes`
Il seguente esempio di codice mostra come utilizzare`GetSMSAttributes`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Get the type of SMS Message sent by default from the AWS SNS service.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
try {
$result = $SnSclient->getSMSAttributes([
'attributes' => ['DefaultSMSType'],
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#get-sms-attributes).
+ Per i dettagli sull'API, consulta [Get SMSAttributes](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/GetSMSAttributes) in *AWS SDK per PHP API Reference*.
### `GetTopicAttributes`
Il seguente esempio di codice mostra come usare`GetTopicAttributes`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$topic = 'arn:aws:sns:us-east-1:111122223333:MyTopic';
try {
$result = $SnSclient->getTopicAttributes([
'TopicArn' => $topic,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per i dettagli sull'API, [GetTopicAttributes](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/GetTopicAttributes)consulta *AWS SDK per PHP API Reference*.
### `ListPhoneNumbersOptedOut`
Il seguente esempio di codice mostra come utilizzare`ListPhoneNumbersOptedOut`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Returns a list of phone numbers that are opted out of receiving SMS messages from your AWS SNS account.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
try {
$result = $SnSclient->listPhoneNumbersOptedOut();
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#list-opted-out-phone-numbers).
+ Per i dettagli sull'API, [ListPhoneNumbersOptedOut](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/ListPhoneNumbersOptedOut)consulta *AWS SDK per PHP API Reference*.
### `ListSubscriptions`
Il seguente esempio di codice mostra come utilizzare`ListSubscriptions`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Returns a list of Amazon SNS subscriptions in the requested region.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
try {
$result = $SnSclient->listSubscriptions();
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per i dettagli sull'API, [ListSubscriptions](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/ListSubscriptions)consulta *AWS SDK per PHP API Reference*.
### `ListTopics`
Il seguente esempio di codice mostra come utilizzare`ListTopics`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Returns a list of the requester's topics from your AWS SNS account in the region specified.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
try {
$result = $SnSclient->listTopics();
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per i dettagli sull'API, [ListTopics](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/ListTopics)consulta *AWS SDK per PHP API Reference*.
### `Publish`
Il seguente esempio di codice mostra come utilizzare`Publish`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Sends a message to an Amazon SNS topic.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$message = 'This message is sent from a Amazon SNS code sample.';
$topic = 'arn:aws:sns:us-east-1:111122223333:MyTopic';
try {
$result = $SnSclient->publish([
'Message' => $message,
'TopicArn' => $topic,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-subscribing-unsubscribing-topics.html#publish-a-message-to-an-sns-topic).
+ Per informazioni dettagliate sull’API, consulta [Pubblicazione](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Publish) nella *documentazione di riferimento dell’API AWS SDK per PHP *.
### `SetSMSAttributes`
Il seguente esempio di codice mostra come usare`SetSMSAttributes`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
try {
$result = $SnSclient->SetSMSAttributes([
'attributes' => [
'DefaultSMSType' => 'Transactional',
],
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#set-sms-attributes).
+ Per i dettagli sull'API, consulta [Set SMSAttributes](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/SetSMSAttributes) in *AWS SDK per PHP API Reference*.
### `SetTopicAttributes`
Il seguente esempio di codice mostra come utilizzare`SetTopicAttributes`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Configure the message delivery status attributes for an Amazon SNS Topic.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$attribute = 'Policy | DisplayName | DeliveryPolicy';
$value = 'First Topic';
$topic = 'arn:aws:sns:us-east-1:111122223333:MyTopic';
try {
$result = $SnSclient->setTopicAttributes([
'AttributeName' => $attribute,
'AttributeValue' => $value,
'TopicArn' => $topic,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per i dettagli sull'API, [SetTopicAttributes](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/SetTopicAttributes)consulta *AWS SDK per PHP API Reference*.
### `Subscribe`
Il seguente esempio di codice mostra come utilizzare`Subscribe`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
Sottoscrive un indirizzo e-mail a un argomento.
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Prepares to subscribe an endpoint by sending the endpoint a confirmation message.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$protocol = 'email';
$endpoint = 'sample@example.com';
$topic = 'arn:aws:sns:us-east-1:111122223333:MyTopic';
try {
$result = $SnSclient->subscribe([
'Protocol' => $protocol,
'Endpoint' => $endpoint,
'ReturnSubscriptionArn' => true,
'TopicArn' => $topic,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
Sottoscrive un endpoint HTTP a un argomento.
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Prepares to subscribe an endpoint by sending the endpoint a confirmation message.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$protocol = 'https';
$endpoint = 'https://';
$topic = 'arn:aws:sns:us-east-1:111122223333:MyTopic';
try {
$result = $SnSclient->subscribe([
'Protocol' => $protocol,
'Endpoint' => $endpoint,
'ReturnSubscriptionArn' => true,
'TopicArn' => $topic,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per informazioni dettagliate sull’API, consulta [Sottoscrizione](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Subscribe) nella *documentazione di riferimento dell’API AWS SDK per PHP *.
### `Unsubscribe`
Il seguente esempio di codice mostra come usare`Unsubscribe`.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Deletes a subscription to an Amazon SNS topic.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$subscription = 'arn:aws:sns:us-east-1:111122223333:MySubscription';
try {
$result = $SnSclient->unsubscribe([
'SubscriptionArn' => $subscription,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-subscribing-unsubscribing-topics.html#unsubscribe-from-a-topic).
+ Per informazioni dettagliate sull’API, consulta [Annullamento della sottoscrizione](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Unsubscribe) nella *documentazione di riferimento dell’API AWS SDK per PHP *.
## Scenari
### Creazione di un’applicazione serverless per gestire foto
L’esempio di codice seguente mostra come creare un’applicazione serverless che consente agli utenti di gestire le foto mediante etichette.
**SDK per PHP**
Mostra come sviluppare un’applicazione per la gestione delle risorse fotografiche che rileva le etichette nelle immagini utilizzando Amazon Rekognition e le archivia per recuperarle in seguito.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Per approfondire l’origine di questo esempio, consulta il post su [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servizi utilizzati in questo esempio**
+ Gateway API
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Simple Storage Service (Amazon S3)
+ Amazon SNS
### Pubblicazione di un SMS
L’esempio di codice seguente mostra come pubblicare messaggi SMS utilizzando Amazon SNS.
**SDK per PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Sends a text message (SMS message) directly to a phone number using Amazon SNS.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$message = 'This message is sent from a Amazon SNS code sample.';
$phone = '+1XXX5550100';
try {
$result = $SnSclient->publish([
'Message' => $message,
'PhoneNumber' => $phone,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#publish-to-a-text-message-sms-message).
+ Per informazioni dettagliate sull’API, consulta [Pubblicazione](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Publish) nella *documentazione di riferimento dell’API AWS SDK per PHP *.
## Esempi serverless
### Invocazione di una funzione Lambda da un trigger Amazon SNS
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dal ricevimento di messaggi da un argomento SNS. La funzione recupera i messaggi dal parametro dell’evento e registra il contenuto di ogni messaggio.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Utilizzo di un evento SNS con Lambda tramite PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
getRecords() as $record) {
$message = $record->getMessage();
// TODO: Implement your custom processing logic here
// Any exception thrown will be logged and the invocation will be marked as failed
echo "Processed Message: $message" . PHP_EOL;
}
}
}
return new Handler();
```
# Esempi per Amazon SQS con SDK per PHP
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per PHP con Amazon SQS.
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**
+ [Esempi serverless](#serverless_examples)
## Esempi serverless
### Invocazione di una funzione Lambda da un trigger Amazon SQS
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di messaggi da una coda SQS. La funzione recupera i messaggi dal parametro dell’evento e registra il contenuto di ogni messaggio.
**SDK per PHP**
C'è di più su. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Utilizzo di un evento SQS con Lambda tramite PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
logger = $logger;
}
/**
* @throws InvalidLambdaEvent
*/
public function handleSqs(SqsEvent $event, Context $context): void
{
foreach ($event->getRecords() as $record) {
$body = $record->getBody();
// TODO: Do interesting work based on the new message
}
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
### Segnalazione di errori di elementi batch per funzioni Lambda con un trigger Amazon SQS
L’esempio di codice seguente mostra come implementare una risposta batch parziale per funzioni Lambda che ricevono eventi da una coda SQS. La funzione riporta gli errori degli elementi batch nella risposta, segnalando a Lambda di riprovare tali messaggi in un secondo momento.
**SDK per PHP**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures).
Segnalazione di errori di elementi batch di SQS con Lambda tramite PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
logger = $logger;
}
/**
* @throws JsonException
* @throws \Bref\Event\InvalidLambdaEvent
*/
public function handleSqs(SqsEvent $event, Context $context): void
{
$this->logger->info("Processing SQS records");
$records = $event->getRecords();
foreach ($records as $record) {
try {
// Assuming the SQS message is in JSON format
$message = json_decode($record->getBody(), true);
$this->logger->info(json_encode($message));
// TODO: Implement your custom processing logic here
} catch (Exception $e) {
$this->logger->error($e->getMessage());
// failed processing the record
$this->markAsFailed($record);
}
}
$totalRecords = count($records);
$this->logger->info("Successfully processed $totalRecords SQS records");
}
}
$logger = new StderrLogger();
return new Handler($logger);
```