D'autres exemples de AWS SDK sont disponibles dans le référentiel [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub .
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Exemples de code pour le kit SDK pour PHP
Les exemples de code suivants vous montrent comment utiliser le AWS SDK pour PHP with AWS.
Les *principes de base* sont des exemples de code qui vous montrent comment effectuer les opérations essentielles au sein d’un service.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
Certains services contiennent des exemples de catégories supplémentaires qui montrent comment tirer parti des bibliothèques ou des fonctions spécifiques au service.
**Ressources supplémentaires**
+ Guide du **[développeur du SDK for PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/welcome.html)** — En savoir plus sur l'utilisation de PHP AWS avec.
+ **[Centre pour développeurs AWS](https://aws.amazon.com/developer/code-examples/?awsf.sdk-code-examples-programming-language=programming-language%23php) ** : exemples de code que vous pouvez filtrer par catégorie ou par recherche en texte intégral.
+ **[AWS Exemples de SDK](https://github.com/awsdocs/aws-doc-sdk-examples)** : GitHub dépôt avec code complet dans les langues préférées. Inclut des instructions sur la configuration et l’exécution du code.
**Topics**
+ [API Gateway](php_3_api-gateway_code_examples.md)
+ [Aurora](php_3_aurora_code_examples.md)
+ [Auto Scaling](php_3_auto-scaling_code_examples.md)
+ [Amazon Bedrock](php_3_bedrock_code_examples.md)
+ [Exécution d’Amazon Bedrock](php_3_bedrock-runtime_code_examples.md)
+ [Amazon DocumentDB](php_3_docdb_code_examples.md)
+ [DynamoDB](php_3_dynamodb_code_examples.md)
+ [Amazon EC2](php_3_ec2_code_examples.md)
+ [AWS Glue](php_3_glue_code_examples.md)
+ [IAM](php_3_iam_code_examples.md)
+ [Kinesis](php_3_kinesis_code_examples.md)
+ [AWS KMS](php_3_kms_code_examples.md)
+ [Lambda](php_3_lambda_code_examples.md)
+ [Amazon MSK](php_3_kafka_code_examples.md)
+ [Amazon RDS](php_3_rds_code_examples.md)
+ [Amazon RDS Data Service](php_3_rds-data_code_examples.md)
+ [Amazon Rekognition](php_3_rekognition_code_examples.md)
+ [Amazon S3](php_3_s3_code_examples.md)
+ [Compartiments de répertoires S3](php_3_s3-directory-buckets_code_examples.md)
+ [Amazon SES](php_3_ses_code_examples.md)
+ [Amazon SNS](php_3_sns_code_examples.md)
+ [Amazon SQS](php_3_sqs_code_examples.md)
# Exemples API Gateway avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l'aide de AWS SDK pour PHP with API Gateway.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Actions](#actions)
+ [Scénarios](#scenarios)
## Actions
### `GetBasePathMapping`
L'exemple de code suivant montre comment utiliser`GetBasePathMapping`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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();
```
+ Pour plus de détails sur l'API, voir [GetBasePathMapping](https://docs.aws.amazon.com/goto/SdkForPHPV3/apigateway-2015-07-09/GetBasePathMapping)la section *Référence des AWS SDK pour PHP API*.
### `ListBasePathMappings`
L'exemple de code suivant montre comment utiliser`ListBasePathMappings`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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();
```
+ Pour plus de détails sur l'API, voir [ListBasePathMappings](https://docs.aws.amazon.com/goto/SdkForPHPV3/apigateway-2015-07-09/ListBasePathMappings)la section *Référence des AWS SDK pour PHP API*.
### `UpdateBasePathMapping`
L'exemple de code suivant montre comment utiliser`UpdateBasePathMapping`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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();
```
+ Pour plus de détails sur l'API, voir [UpdateBasePathMapping](https://docs.aws.amazon.com/goto/SdkForPHPV3/apigateway-2015-07-09/UpdateBasePathMapping)la section *Référence des AWS SDK pour PHP API*.
## Scénarios
### Création d’une application sans serveur pour gérer des photos
L'exemple de code suivant montre comment créer une application sans serveur permettant aux utilisateurs de gérer des photos à l'aide d'étiquettes.
**Kit SDK pour PHP**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
# Exemples Aurora avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide d'Aurora.
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Scénarios](#scenarios)
## Scénarios
### Créer un outil de suivi des éléments de travail sans serveur Aurora
L’exemple de code suivant montre comment créer une application Web qui suit des éléments de travail dans une base de données Amazon Aurora sans serveur et envoie des rapports par e-mail à l’aide d’Amazon Simple Email Service (Amazon SES).
**Kit SDK pour PHP**
Montre comment utiliser le AWS SDK pour PHP pour créer une application Web qui suit les éléments de travail dans une base de données Amazon RDS et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise une interface créée avec React.js pour interagir avec un backend RESTful PHP.
+ Intégrez une application Web React.js à AWS des services.
+ Répertoriez, ajoutez, mettez à jour et supprimez des éléments dans une table Amazon RDS.
+ Envoyez un rapport par e-mail sur les éléments de travail filtrés à l’aide d’Amazon SES.
+ Déployez et gérez des exemples de ressources à l'aide du AWS CloudFormation script inclus.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
# Exemples Auto Scaling avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l'aide de AWS SDK pour PHP with Auto Scaling.
Les *principes de base* sont des exemples de code qui vous montrent comment effectuer les opérations essentielles au sein d’un service.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Mise en route](#get_started)
+ [Principes de base](#basics)
+ [Actions](#actions)
## Mise en route
### Bonjour Auto Scaling
L'exemple de code suivant montre comment commencer à utiliser Auto Scaling.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [DescribeAutoScalingGroups](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeAutoScalingGroups)la section *Référence des AWS SDK pour PHP API*.
## Principes de base
### Principes de base
L’exemple de code suivant illustre comment :
+ créer un groupe Amazon EC2 Auto Scaling avec un modèle de lancement et des zones de disponibilité, et obtenir des informations sur l’exécution des instances ;
+ Activez la collecte CloudWatch de métriques Amazon.
+ mettre à jour la capacité souhaitée du groupe et attendre qu’une instance démarre ;
+ résilier la plus ancienne instance du groupe ;
+ répertorier les activités de mise à l’échelle qui se produisent en réponse aux demandes des utilisateurs et aux modifications de capacité ;
+ Obtenez des statistiques pour CloudWatch les métriques, puis nettoyez les ressources.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
}
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK pour 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)
## Actions
### `CreateAutoScalingGroup`
L'exemple de code suivant montre comment utiliser`CreateAutoScalingGroup`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
],
]);
}
```
+ Pour plus de détails sur l'API, voir [CreateAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/CreateAutoScalingGroup)la section *Référence des AWS SDK pour PHP API*.
### `DeleteAutoScalingGroup`
L'exemple de code suivant montre comment utiliser`DeleteAutoScalingGroup`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [DeleteAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DeleteAutoScalingGroup)la section *Référence des AWS SDK pour PHP API*.
### `DescribeAutoScalingGroups`
L'exemple de code suivant montre comment utiliser`DescribeAutoScalingGroups`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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
]);
}
```
+ Pour plus de détails sur l'API, voir [DescribeAutoScalingGroups](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeAutoScalingGroups)la section *Référence des AWS SDK pour PHP API*.
### `DescribeAutoScalingInstances`
L'exemple de code suivant montre comment utiliser`DescribeAutoScalingInstances`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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
]);
}
```
+ Pour plus de détails sur l'API, voir [DescribeAutoScalingInstances](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeAutoScalingInstances)la section *Référence des AWS SDK pour PHP API*.
### `DescribeScalingActivities`
L'exemple de code suivant montre comment utiliser`DescribeScalingActivities`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [DescribeScalingActivities](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeScalingActivities)la section *Référence des AWS SDK pour PHP API*.
### `DisableMetricsCollection`
L'exemple de code suivant montre comment utiliser`DisableMetricsCollection`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [DisableMetricsCollection](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DisableMetricsCollection)la section *Référence des AWS SDK pour PHP API*.
### `EnableMetricsCollection`
L'exemple de code suivant montre comment utiliser`EnableMetricsCollection`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [EnableMetricsCollection](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/EnableMetricsCollection)la section *Référence des AWS SDK pour PHP API*.
### `SetDesiredCapacity`
L'exemple de code suivant montre comment utiliser`SetDesiredCapacity`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [SetDesiredCapacity](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/SetDesiredCapacity)la section *Référence des AWS SDK pour PHP API*.
### `TerminateInstanceInAutoScalingGroup`
L'exemple de code suivant montre comment utiliser`TerminateInstanceInAutoScalingGroup`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
}
```
+ Pour plus de détails sur l'API, voir [TerminateInstanceInAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/TerminateInstanceInAutoScalingGroup)la section *Référence des AWS SDK pour PHP API*.
### `UpdateAutoScalingGroup`
L'exemple de code suivant montre comment utiliser`UpdateAutoScalingGroup`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [UpdateAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/UpdateAutoScalingGroup)la section *Référence des AWS SDK pour PHP API*.
# Exemples Amazon Bedrock avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants en utilisant Amazon Bedrock. AWS SDK pour PHP
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Actions](#actions)
## Actions
### `ListFoundationModels`
L'exemple de code suivant montre comment utiliser`ListFoundationModels`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock#code-examples).
Répertoriez les modèles de fondation Amazon Bedrock disponibles.
```
public function listFoundationModels()
{
$bedrockClient = new BedrockClient([
'region' => 'us-west-2',
'profile' => 'default'
]);
$response = $bedrockClient->listFoundationModels();
return $response['modelSummaries'];
}
```
+ Pour plus de détails sur l'API, voir [ListFoundationModels](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-2023-04-20/ListFoundationModels)la section *Référence des AWS SDK pour PHP API*.
# Exemples Amazon Bedrock Runtime avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide d'Amazon Bedrock Runtime.
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Scénarios](#scenarios)
+ [Amazon Nova](#amazon_nova)
+ [Générateur d’images Amazon Titan](#amazon_titan_image_generator)
+ [Anthropic Claude](#anthropic_claude)
+ [Stable Diffusion](#stable_diffusion)
## Scénarios
### Invocation de plusieurs modèles de fondation sur Amazon Bedrock
L'exemple de code suivant montre comment préparer et envoyer une invite à différents modèles en langage large (LLMs) sur Amazon Bedrock
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime/#code-examples).
Invoquez plusieurs LLMs sur 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;
}
}
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK pour 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’exemple de code suivant montre comment envoyer un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de 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();
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK pour PHP *.
## Générateur d’images Amazon Titan
### InvokeModel
L’exemple de code suivant montre comment invoquer Amazon Titan Image sur Amazon Bedrock pour générer une image.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Créez une image avec le générateur d’images 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;
}
```
+ Pour plus de détails sur l'API, voir [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)la section *Référence des AWS SDK pour PHP API*.
## Anthropic Claude
### InvokeModel
L’exemple de code suivant montre comment envoyer un message texte à Anthropic Claude à l’aide de l’API Invoke Model.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Invoquez le modèle de fondation Anthropic Claude 2 pour générer du texte.
```
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;
}
```
+ Pour plus de détails sur l'API, voir [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)la section *Référence des AWS SDK pour PHP API*.
## Stable Diffusion
### InvokeModel
L’exemple de code suivant montre comment invoquer Stability.ai Stable Diffusion XL sur Amazon Bedrock pour générer une image.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Créez une image avec 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;
}
```
+ Pour plus de détails sur l'API, voir [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)la section *Référence des AWS SDK pour PHP API*.
# Exemples Amazon DocumentDB avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide d'Amazon DocumentDB.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Exemples sans serveur](#serverless_examples)
## Exemples sans serveur
### Invocation d’une fonction Lambda à partir d’un déclencheur Amazon DocumentDB
L’exemple de code suivant montre comment implémenter une fonction Lambda qui reçoit un événement déclenché par la réception d’enregistrements à partir d’un flux de modifications DocumentDB. La fonction récupère les données utiles DocumentDB et journalise le contenu de l’enregistrement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Consommation d’un événement Amazon DocumentDB avec Lambda en utilisant 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();
```
# Exemples DynamoDB avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide de DynamoDB.
Les *principes de base* sont des exemples de code qui vous montrent comment effectuer les opérations essentielles au sein d’un service.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Principes de base](#basics)
+ [Actions](#actions)
+ [Scénarios](#scenarios)
+ [Exemples sans serveur](#serverless_examples)
## Principes de base
### Principes de base
L’exemple de code suivant illustre comment :
+ Créez une table pouvant contenir des données vidéo.
+ Insérer, récupérez et mettez à jour un seul film dans la table.
+ Écrivez des données vidéo dans la table à partir d’un exemple de fichier JSON.
+ Recherchez les films sortis au cours d’une année donnée.
+ Recherchez les films sortis au cours d’une plage d’années spécifique.
+ Supprimez un film de la table, puis supprimez la table.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/dynamodb#code-examples).
Dans la mesure où cet exemple utilise des fichiers de support, veillez à [lire les instructions](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/php/README.md#prerequisites) contenues dans le fichier README.md contenant des exemples 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);
}
}
```
+ Pour plus d’informations sur l’API consultez les rubriques suivantes dans la *référence de l’API AWS SDK pour 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)
+ [Interrogation](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Query)
+ [Analyser](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)
## Actions
### `BatchExecuteStatement`
L'exemple de code suivant montre comment utiliser`BatchExecuteStatement`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
],
],
]);
}
```
+ Pour plus de détails sur l'API, voir [BatchExecuteStatement](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/BatchExecuteStatement)la section *Référence des AWS SDK pour PHP API*.
### `BatchWriteItem`
L'exemple de code suivant montre comment utiliser`BatchWriteItem`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
}
```
+ Pour plus de détails sur l'API, voir [BatchWriteItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/BatchWriteItem)la section *Référence des AWS SDK pour PHP API*.
### `CreateTable`
L'exemple de code suivant montre comment utiliser`CreateTable`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/dynamodb#code-examples).
Créer une table.
```
$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],
]);
}
```
+ Pour plus de détails sur l'API, voir [CreateTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/CreateTable)la section *Référence des AWS SDK pour PHP API*.
### `DeleteItem`
L'exemple de code suivant montre comment utiliser`DeleteItem`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [DeleteItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DeleteItem)la section *Référence des AWS SDK pour PHP API*.
### `DeleteTable`
L'exemple de code suivant montre comment utiliser`DeleteTable`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
});
}
```
+ Pour plus de détails sur l'API, voir [DeleteTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DeleteTable)la section *Référence des AWS SDK pour PHP API*.
### `ExecuteStatement`
L'exemple de code suivant montre comment utiliser`ExecuteStatement`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [ExecuteStatement](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/ExecuteStatement)la section *Référence des AWS SDK pour PHP API*.
### `GetItem`
L'exemple de code suivant montre comment utiliser`GetItem`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [GetItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/GetItem)la section *Référence des AWS SDK pour PHP API*.
### `ListTables`
L'exemple de code suivant montre comment utiliser`ListTables`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [ListTables](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/ListTables)la section *Référence des AWS SDK pour PHP API*.
### `PutItem`
L'exemple de code suivant montre comment utiliser`PutItem`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [PutItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/PutItem)la section *Référence des AWS SDK pour PHP API*.
### `Query`
L'exemple de code suivant montre comment utiliser`Query`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus d’informations sur l’API, consultez [Requête](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Query) dans la *référence d’API AWS SDK pour PHP *.
### `Scan`
L'exemple de code suivant montre comment utiliser`Scan`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l’API, consultez [Scan](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Scan) dans la *Référence des API du kit AWS SDK pour PHP *.
### `UpdateItem`
L'exemple de code suivant montre comment utiliser`UpdateItem`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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
]
],
]);
}
```
+ Pour plus de détails sur l'API, voir [UpdateItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/UpdateItem)la section *Référence des AWS SDK pour PHP API*.
## Scénarios
### Création d’une application sans serveur pour gérer des photos
L'exemple de code suivant montre comment créer une application sans serveur permettant aux utilisateurs de gérer des photos à l'aide d'étiquettes.
**Kit SDK pour PHP**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
### Interrogation d’une table à l’aide de lots d’instructions PartiQL
L’exemple de code suivant illustre comment :
+ Obtenez un lot d’éléments en exécutant plusieurs instructions SELECT.
+ Ajoutez un lot d’éléments en exécutant plusieurs instructions INSERT.
+ Mettez à jour un lot d’éléments en exécutant plusieurs instructions UPDATE.
+ Supprimez un lot d’éléments en exécutant plusieurs instructions DELETE.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
],
],
]);
}
```
+ Pour plus de détails sur l'API, voir [BatchExecuteStatement](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/BatchExecuteStatement)la section *Référence des AWS SDK pour PHP API*.
### Interrogation d’une table à l’aide de PartiQL
L’exemple de code suivant illustre comment :
+ Obtenez un élément en exécutant une instruction SELECT.
+ Ajoutez un élément en exécutant une instruction INSERT.
+ Mettez à jour un élément en exécutant une instruction UPDATE.
+ Supprimez un élément en exécutant une instruction DELETE.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [ExecuteStatement](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/ExecuteStatement)la section *Référence des AWS SDK pour PHP API*.
## Exemples sans serveur
### Invocation d’une fonction Lambda à partir d’un déclencheur DynamoDB
L’exemple de code suivant montre comment mettre en œuvre une fonction Lambda qui reçoit un événement déclenché par la réception d’enregistrements à partir d’un flux DynamoDB. La fonction récupère les données utiles DynamoDB et journalise le contenu de l’enregistrement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda).
Consommation d’un événement DynamoDB avec Lambda en utilisant 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);
```
### Signalement des échecs d’articles par lots pour les fonctions Lambda à l’aide d’un déclencheur DynamoDB
L’exemple de code suivant montre comment mettre en œuvre une réponse partielle par lots pour les fonctions Lambda qui reçoivent des événements à partir d’un flux DynamoDB. La fonction signale les défaillances échecs d’articles par lots dans la réponse, en indiquant à Lambda de réessayer ces messages ultérieurement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda-with-batch-item-handling).
Signalement des échecs d’articles par lots DynamoDB avec Lambda à l’aide de 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);
```
# Exemples Amazon EC2 avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide d'Amazon EC2.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Actions](#actions)
## Actions
### `CreateVpc`
L'exemple de code suivant montre comment utiliser`CreateVpc`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, voir [CreateVpc](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/CreateVpc)la section *Référence des AWS SDK pour PHP API*.
### `CreateVpcEndpoint`
L'exemple de code suivant montre comment utiliser`CreateVpcEndpoint`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, voir [CreateVpcEndpoint](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/CreateVpcEndpoint)la section *Référence des AWS SDK pour PHP API*.
### `DeleteVpc`
L'exemple de code suivant montre comment utiliser`DeleteVpc`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, voir [DeleteVpc](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/DeleteVpc)la section *Référence des AWS SDK pour PHP API*.
### `DeleteVpcEndpoints`
L'exemple de code suivant montre comment utiliser`DeleteVpcEndpoints`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, voir [DeleteVpcEndpoints](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/DeleteVpcEndpoints)la section *Référence des AWS SDK pour PHP API*.
### `DescribeRouteTables`
L'exemple de code suivant montre comment utiliser`DescribeRouteTables`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
```
+ Pour plus de détails sur l'API, voir [DescribeRouteTables](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/DescribeRouteTables)la section *Référence des AWS SDK pour PHP API*.
# AWS Glue exemples d'utilisation du SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l'aide du AWS SDK pour PHP with AWS Glue.
Les *principes de base* sont des exemples de code qui vous montrent comment effectuer les opérations essentielles au sein d’un service.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Principes de base](#basics)
+ [Actions](#actions)
## Principes de base
### Principes de base
L’exemple de code suivant illustre comment :
+ Créez un Crawler qui indexe un compartiment Amazon S3 public et génère une base de données de métadonnées au format CSV.
+ Répertoriez les informations relatives aux bases de données et aux tables de votre AWS Glue Data Catalog.
+ Créez une tâche pour extraire les données CSV du compartiment S3, transformer les données et charger la sortie au format JSON dans un autre compartiment S3.
+ Répertoriez les informations relatives aux exécutions de tâches, visualisez les données transformées et nettoyez les ressources.
Pour plus d'informations, consultez [Tutoriel : prise en main de AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/ug/tutorial-create-job.html).
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
}
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK pour 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)
## Actions
### `CreateCrawler`
L'exemple de code suivant montre comment utiliser`CreateCrawler`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]]
],
]);
});
}
```
+ Pour plus de détails sur l'API, voir [CreateCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/CreateCrawler)la section *Référence des AWS SDK pour PHP API*.
### `CreateJob`
L'exemple de code suivant montre comment utiliser`CreateJob`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [CreateJob](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/CreateJob)la section *Référence des AWS SDK pour PHP API*.
### `DeleteCrawler`
L'exemple de code suivant montre comment utiliser`DeleteCrawler`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [DeleteCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteCrawler)la section *Référence des AWS SDK pour PHP API*.
### `DeleteDatabase`
L'exemple de code suivant montre comment utiliser`DeleteDatabase`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [DeleteDatabase](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteDatabase)la section *Référence des AWS SDK pour PHP API*.
### `DeleteJob`
L'exemple de code suivant montre comment utiliser`DeleteJob`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [DeleteJob](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteJob)la section *Référence des AWS SDK pour PHP API*.
### `DeleteTable`
L'exemple de code suivant montre comment utiliser`DeleteTable`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [DeleteTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteTable)la section *Référence des AWS SDK pour PHP API*.
### `GetCrawler`
L'exemple de code suivant montre comment utiliser`GetCrawler`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
});
}
```
+ Pour plus de détails sur l'API, voir [GetCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetCrawler)la section *Référence des AWS SDK pour PHP API*.
### `GetDatabase`
L'exemple de code suivant montre comment utiliser`GetDatabase`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
});
}
```
+ Pour plus de détails sur l'API, voir [GetDatabase](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetDatabase)la section *Référence des AWS SDK pour PHP API*.
### `GetJobRun`
L'exemple de code suivant montre comment utiliser`GetJobRun`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [GetJobRun](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetJobRun)la section *Référence des AWS SDK pour PHP API*.
### `GetJobRuns`
L'exemple de code suivant montre comment utiliser`GetJobRuns`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [GetJobRuns](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetJobRuns)la section *Référence des AWS SDK pour PHP API*.
### `GetTables`
L'exemple de code suivant montre comment utiliser`GetTables`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [GetTables](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetTables)la section *Référence des AWS SDK pour PHP API*.
### `ListJobs`
L'exemple de code suivant montre comment utiliser`ListJobs`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [ListJobs](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/ListJobs)la section *Référence des AWS SDK pour PHP API*.
### `StartCrawler`
L'exemple de code suivant montre comment utiliser`StartCrawler`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, voir [StartCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/StartCrawler)la section *Référence des AWS SDK pour PHP API*.
### `StartJobRun`
L'exemple de code suivant montre comment utiliser`StartJobRun`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
],
]);
}
```
+ Pour plus de détails sur l'API, voir [StartJobRun](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/StartJobRun)la section *Référence des AWS SDK pour PHP API*.
# Exemples IAM avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l'aide de AWS SDK pour PHP with IAM.
Les *principes de base* sont des exemples de code qui vous montrent comment effectuer les opérations essentielles au sein d’un service.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Principes de base](#basics)
+ [Actions](#actions)
## Principes de base
### Principes de base
L’exemple de code suivant montre comment créer un utilisateur et endosser un rôle.
**Avertissement**
Afin d’éviter les risques de sécurité, n’employez pas les utilisateurs IAM pour l’authentification lorsque vous développez des logiciels spécialisés ou lorsque vous travaillez avec des données réelles. Préférez la fédération avec un fournisseur d’identité tel que [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
+ Créer un utilisateur sans autorisation.
+ Créer un rôle qui accorde l’autorisation de répertorier les compartiments Amazon S3 pour le compte.
+ Ajouter une politique pour permettre à l’utilisateur d’assumer le rôle.
+ Assumez le rôle et répertorier les compartiments S3 à l’aide d’informations d’identification temporaires, puis nettoyez les ressources.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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";
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK pour 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)
## Actions
### `AttachRolePolicy`
L'exemple de code suivant montre comment utiliser`AttachRolePolicy`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
});
}
```
+ Pour plus de détails sur l'API, voir [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/AttachRolePolicy)la section *Référence des AWS SDK pour PHP API*.
### `CreatePolicy`
L'exemple de code suivant montre comment utiliser`CreatePolicy`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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'];
}
```
+ Pour plus de détails sur l'API, voir [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreatePolicy)la section *Référence des AWS SDK pour PHP API*.
### `CreateRole`
L'exemple de code suivant montre comment utiliser`CreateRole`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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'];
}
```
+ Pour plus de détails sur l'API, voir [CreateRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateRole)la section *Référence des AWS SDK pour PHP API*.
### `CreateServiceLinkedRole`
L'exemple de code suivant montre comment utiliser`CreateServiceLinkedRole`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [CreateServiceLinkedRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateServiceLinkedRole)la section *Référence des AWS SDK pour PHP API*.
### `CreateUser`
L'exemple de code suivant montre comment utiliser`CreateUser`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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'];
}
```
+ Pour plus de détails sur l'API, voir [CreateUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateUser)la section *Référence des AWS SDK pour PHP API*.
### `GetAccountPasswordPolicy`
L'exemple de code suivant montre comment utiliser`GetAccountPasswordPolicy`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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();
}
```
+ Pour plus de détails sur l'API, voir [GetAccountPasswordPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/GetAccountPasswordPolicy)la section *Référence des AWS SDK pour PHP API*.
### `GetPolicy`
L'exemple de code suivant montre comment utiliser`GetPolicy`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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]);
});
}
```
+ Pour plus de détails sur l'API, voir [GetPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/GetPolicy)la section *Référence des AWS SDK pour PHP API*.
### `GetRole`
L'exemple de code suivant montre comment utiliser`GetRole`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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]);
});
}
```
+ Pour plus de détails sur l'API, voir [GetRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/GetRole)la section *Référence des AWS SDK pour PHP API*.
### `ListAttachedRolePolicies`
L'exemple de code suivant montre comment utiliser`ListAttachedRolePolicies`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [ListAttachedRolePolicies](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListAttachedRolePolicies)la section *Référence des AWS SDK pour PHP API*.
### `ListGroups`
L'exemple de code suivant montre comment utiliser`ListGroups`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [ListGroups](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListGroups)la section *Référence des AWS SDK pour PHP API*.
### `ListPolicies`
L'exemple de code suivant montre comment utiliser`ListPolicies`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [ListPolicies](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListPolicies)la section *Référence des AWS SDK pour PHP API*.
### `ListRolePolicies`
L'exemple de code suivant montre comment utiliser`ListRolePolicies`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
});
}
```
+ Pour plus de détails sur l'API, voir [ListRolePolicies](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListRolePolicies)la section *Référence des AWS SDK pour PHP API*.
### `ListRoles`
L'exemple de code suivant montre comment utiliser`ListRoles`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [ListRoles](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListRoles)la section *Référence des AWS SDK pour PHP API*.
### `ListSAMLProviders`
L'exemple de code suivant montre comment utiliser`ListSAMLProviders`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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();
}
```
+ Pour plus de détails sur l'API, consultez [la section Liste SAMLProviders](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListSAMLProviders) dans la *référence des AWS SDK pour PHP API*.
### `ListUsers`
L'exemple de code suivant montre comment utiliser`ListUsers`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, reportez-vous [ListUsers](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListUsers)à la section *Référence des AWS SDK pour PHP API*.
# Exemples Kinesis avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l'aide de AWS SDK pour PHP with Kinesis.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Exemples sans serveur](#serverless_examples)
## Exemples sans serveur
### Invoquer une fonction Lambda à partir d’un déclencheur Kinesis
L’exemple de code suivant montre comment implémenter une fonction Lambda qui reçoit un événement déclenché par la réception d’enregistrements à partir d’un flux Kinesis. La fonction récupère la charge utile Kinesis, décode à partir de Base64 et enregistre le contenu de l’enregistrement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda).
Consommation d’un événement Kinesis avec Lambda à l’aide de 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);
```
### Signalement des échecs d’articles par lots pour les fonctions Lambda à l’aide d’un déclencheur Kinesis
L’exemple de code suivant montre comment mettre en œuvre une réponse partielle par lots pour les fonctions Lambda qui reçoivent des événements à partir d’un flux Kinesis. La fonction signale les défaillances échecs d’articles par lots dans la réponse, en indiquant à Lambda de réessayer ces messages ultérieurement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda-with-batch-item-handling).
Signalement des échecs d’articles par lots Kinesis avec Lambda à l’aide de 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 exemples d'utilisation du SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l'aide du AWS SDK pour PHP with AWS KMS.
Les *principes de base* sont des exemples de code qui vous montrent comment effectuer les opérations essentielles au sein d’un service.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Mise en route](#get_started)
+ [Principes de base](#basics)
+ [Actions](#actions)
## Mise en route
### Bonjour AWS KMS
L’exemple de code suivant montre comment démarrer avec AWS Key Management Service.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [ListKeys](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListKeys)à la section *Référence des AWS SDK pour PHP API*.
## Principes de base
### Principes de base
L’exemple de code suivant illustre comment :
+ créer une clé KMS ;
+ répertorier les clés KMS de votre compte et obtenir des informations les concernant ;
+ Activez et désactivez les clés KMS.
+ générer une clé de données symétrique qui peut être utilisée pour le chiffrement côté client ;
+ générer une clé asymétrique utilisée pour signer numériquement les données ;
+ baliser des clés ;
+ supprimer des clés KMS.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
}
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK pour 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 (Déchiffrer)](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 (Chiffrer)](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 (Signer)](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)
## Actions
### `CreateAlias`
L'exemple de code suivant montre comment utiliser`CreateAlias`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateAlias](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateAlias)à la section *Référence des AWS SDK pour PHP API*.
### `CreateGrant`
L'exemple de code suivant montre comment utiliser`CreateGrant`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateGrant](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateGrant)à la section *Référence des AWS SDK pour PHP API*.
### `CreateKey`
L'exemple de code suivant montre comment utiliser`CreateKey`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateKey)à la section *Référence des AWS SDK pour PHP API*.
### `Decrypt`
L'exemple de code suivant montre comment utiliser`Decrypt`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l’API, consultez [Decrypt](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Decrypt) dans la *Référence des API du kit AWS SDK pour PHP *.
### `DeleteAlias`
L'exemple de code suivant montre comment utiliser`DeleteAlias`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteAlias](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/DeleteAlias)à la section *Référence des AWS SDK pour PHP API*.
### `DescribeKey`
L'exemple de code suivant montre comment utiliser`DescribeKey`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DescribeKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/DescribeKey)à la section *Référence des AWS SDK pour PHP API*.
### `DisableKey`
L'exemple de code suivant montre comment utiliser`DisableKey`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DisableKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/DisableKey)à la section *Référence des AWS SDK pour PHP API*.
### `EnableKey`
L'exemple de code suivant montre comment utiliser`EnableKey`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [EnableKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/EnableKey)à la section *Référence des AWS SDK pour PHP API*.
### `Encrypt`
L'exemple de code suivant montre comment utiliser`Encrypt`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l’API, consultez [Encrypt](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Encrypt) dans la *Référence des API du kit AWS SDK pour PHP *.
### `ListAliases`
L'exemple de code suivant montre comment utiliser`ListAliases`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [ListAliases](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListAliases)à la section *Référence des AWS SDK pour PHP API*.
### `ListGrants`
L'exemple de code suivant montre comment utiliser`ListGrants`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [ListGrants](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListGrants)à la section *Référence des AWS SDK pour PHP API*.
### `ListKeys`
L'exemple de code suivant montre comment utiliser`ListKeys`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [ListKeys](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListKeys)à la section *Référence des AWS SDK pour PHP API*.
### `PutKeyPolicy`
L'exemple de code suivant montre comment utiliser`PutKeyPolicy`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [PutKeyPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/PutKeyPolicy)à la section *Référence des AWS SDK pour PHP API*.
### `RevokeGrant`
L'exemple de code suivant montre comment utiliser`RevokeGrant`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [RevokeGrant](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/RevokeGrant)à la section *Référence des AWS SDK pour PHP API*.
### `ScheduleKeyDeletion`
L'exemple de code suivant montre comment utiliser`ScheduleKeyDeletion`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [ScheduleKeyDeletion](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ScheduleKeyDeletion)à la section *Référence des AWS SDK pour PHP API*.
### `Sign`
L'exemple de code suivant montre comment utiliser`Sign`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l’API, consultez [Sign](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Sign) dans la *Référence des API du kit AWS SDK pour PHP *.
### `TagResource`
L'exemple de code suivant montre comment utiliser`TagResource`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [TagResource](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/TagResource)à la section *Référence des AWS SDK pour PHP API*.
# Exemples Lambda avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide de Lambda.
Les *principes de base* sont des exemples de code qui vous montrent comment effectuer les opérations essentielles au sein d’un service.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Principes de base](#basics)
+ [Actions](#actions)
+ [Scénarios](#scenarios)
+ [Exemples sans serveur](#serverless_examples)
## Principes de base
### Principes de base
L’exemple de code suivant illustre comment :
+ Créer un rôle IAM et une fonction Lambda, puis charger le code du gestionnaire.
+ Invoquer la fonction avec un seul paramètre et obtenir des résultats.
+ Mettre à jour le code de la fonction et configurer avec une variable d’environnement.
+ Invoquer la fonction avec de nouveaux paramètres et obtenir des résultats. Afficher le journal d’exécution renvoyé.
+ Répertorier les fonctions pour votre compte, puis nettoyer les ressources.
Pour plus d’informations, consultez [Créer une fonction Lambda à l’aide de la console](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html).
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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";
}
}
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK pour 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)
## Actions
### `CreateFunction`
L'exemple de code suivant montre comment utiliser`CreateFunction`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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",
]);
});
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateFunction](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/CreateFunction)à la section *Référence des AWS SDK pour PHP API*.
### `DeleteFunction`
L'exemple de code suivant montre comment utiliser`DeleteFunction`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteFunction](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/DeleteFunction)à la section *Référence des AWS SDK pour PHP API*.
### `GetFunction`
L'exemple de code suivant montre comment utiliser`GetFunction`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, reportez-vous [GetFunction](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/GetFunction)à la section *Référence des AWS SDK pour PHP API*.
### `Invoke`
L'exemple de code suivant montre comment utiliser`Invoke`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour en savoir plus sur l’API, consultez [Invoke](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/Invoke) dans la *Référence de l’API AWS SDK pour PHP *.
### `ListFunctions`
L'exemple de code suivant montre comment utiliser`ListFunctions`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, reportez-vous [ListFunctions](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/ListFunctions)à la section *Référence des AWS SDK pour PHP API*.
### `UpdateFunctionCode`
L'exemple de code suivant montre comment utiliser`UpdateFunctionCode`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateFunctionCode](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/UpdateFunctionCode)à la section *Référence des AWS SDK pour PHP API*.
### `UpdateFunctionConfiguration`
L'exemple de code suivant montre comment utiliser`UpdateFunctionConfiguration`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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,
]);
}
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateFunctionConfiguration](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/UpdateFunctionConfiguration)à la section *Référence des AWS SDK pour PHP API*.
## Scénarios
### Création d’une application sans serveur pour gérer des photos
L'exemple de code suivant montre comment créer une application sans serveur permettant aux utilisateurs de gérer des photos à l'aide d'étiquettes.
**Kit SDK pour PHP**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
## Exemples sans serveur
### Connexion à une base de données Amazon RDS dans une fonction Lambda
L’exemple de code suivant montre comment implémenter une fonction Lambda qui se connecte à une base de données RDS. La fonction effectue une simple requête de base de données et renvoie le résultat.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Connexion à une base de données Amazon RDS dans une fonction Lambda à l’aide de 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);
```
### Invoquer une fonction Lambda à partir d’un déclencheur Kinesis
L’exemple de code suivant montre comment implémenter une fonction Lambda qui reçoit un événement déclenché par la réception d’enregistrements à partir d’un flux Kinesis. La fonction récupère la charge utile Kinesis, décode à partir de Base64 et enregistre le contenu de l’enregistrement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda).
Consommation d’un événement Kinesis avec Lambda à l’aide de 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);
```
### Invocation d’une fonction Lambda à partir d’un déclencheur DynamoDB
L’exemple de code suivant montre comment mettre en œuvre une fonction Lambda qui reçoit un événement déclenché par la réception d’enregistrements à partir d’un flux DynamoDB. La fonction récupère les données utiles DynamoDB et journalise le contenu de l’enregistrement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda).
Consommation d’un événement DynamoDB avec Lambda en utilisant 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);
```
### Invocation d’une fonction Lambda à partir d’un déclencheur Amazon DocumentDB
L’exemple de code suivant montre comment implémenter une fonction Lambda qui reçoit un événement déclenché par la réception d’enregistrements à partir d’un flux de modifications DocumentDB. La fonction récupère les données utiles DocumentDB et journalise le contenu de l’enregistrement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Consommation d’un événement Amazon DocumentDB avec Lambda en utilisant 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();
```
### Invocation d’une fonction Lambda à partir d’un déclencheur Amazon MSK
L’exemple de code suivant montre comment implémenter une fonction Lambda qui reçoit un événement déclenché par la réception d’enregistrements à partir d’un cluster Amazon MSK. La fonction récupère les données utiles MSK et journalise le contenu de l’enregistrement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda).
Consommation d’un événement Amazon MSK avec Lambda en utilisant 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);
```
### Invoquer une fonction lambda à partir d’un déclencheur Amazon S3
L’exemple de code suivant montre comment implémenter une fonction Lambda qui reçoit un événement déclenché par le chargement d’un objet vers un compartiment S3. La fonction extrait le nom du compartiment S3 et la clé de l’objet à partir du paramètre d’événement et appelle l’API Amazon S3 pour récupérer et consigner le type de contenu de l’objet.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Consommation d’un événement S3 avec Lambda à l’aide de 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);
```
### Invocation d’une fonction lambda à partir d’un déclencheur Amazon SNS
L’exemple de code suivant montre comment implémenter une fonction Lambda qui reçoit un événement déclenché par la réception de messages à partir d’une rubrique SNS. La fonction extrait les messages du paramètre d’événement et consigne le contenu de chaque message.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Utilisation d’un événement SNS avec Lambda à l’aide de 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();
```
### Invoquer une fonction Lambda à partir d’un déclencheur Amazon SQS
L’exemple de code suivant montre comment implémenter une fonction Lambda qui reçoit un événement déclenché par la réception de messages à partir d’une file d’attente SQS. La fonction extrait les messages du paramètre d’événement et consigne le contenu de chaque message.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Consommation d’un événement SQS avec Lambda à l’aide de 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);
```
### Signalement des échecs d’articles par lots pour les fonctions Lambda à l’aide d’un déclencheur Kinesis
L’exemple de code suivant montre comment mettre en œuvre une réponse partielle par lots pour les fonctions Lambda qui reçoivent des événements à partir d’un flux Kinesis. La fonction signale les défaillances échecs d’articles par lots dans la réponse, en indiquant à Lambda de réessayer ces messages ultérieurement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda-with-batch-item-handling).
Signalement des échecs d’articles par lots Kinesis avec Lambda à l’aide de 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);
```
### Signalement des échecs d’articles par lots pour les fonctions Lambda à l’aide d’un déclencheur DynamoDB
L’exemple de code suivant montre comment mettre en œuvre une réponse partielle par lots pour les fonctions Lambda qui reçoivent des événements à partir d’un flux DynamoDB. La fonction signale les défaillances échecs d’articles par lots dans la réponse, en indiquant à Lambda de réessayer ces messages ultérieurement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda-with-batch-item-handling).
Signalement des échecs d’articles par lots DynamoDB avec Lambda à l’aide de 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);
```
### Signalement des échecs d’articles par lots pour les fonctions Lambda à l’aide d’un déclencheur Amazon SQS
L’exemple de code suivant montre comment mettre en œuvre une réponse partielle par lots pour les fonctions Lambda qui reçoivent des événements à partir d’une file d’attente SQS. La fonction signale les défaillances échecs d’articles par lots dans la réponse, en indiquant à Lambda de réessayer ces messages ultérieurement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures).
Signalement des échecs d’articles par lots SQS avec Lambda à l’aide de 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);
```
# Exemples Amazon MSK avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide d'Amazon MSK.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Exemples sans serveur](#serverless_examples)
## Exemples sans serveur
### Invocation d’une fonction Lambda à partir d’un déclencheur Amazon MSK
L’exemple de code suivant montre comment implémenter une fonction Lambda qui reçoit un événement déclenché par la réception d’enregistrements à partir d’un cluster Amazon MSK. La fonction récupère les données utiles MSK et journalise le contenu de l’enregistrement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda).
Consommation d’un événement Amazon MSK avec Lambda en utilisant 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);
```
# Exemples Amazon RDS avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide d'Amazon RDS.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Actions](#actions)
+ [Scénarios](#scenarios)
+ [Exemples sans serveur](#serverless_examples)
## Actions
### `CreateDBInstance`
L'exemple de code suivant montre comment utiliser`CreateDBInstance`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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";
}
```
+ Pour plus de détails sur l'API, consultez [Create DBInstance](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/CreateDBInstance) in *AWS SDK pour PHP API Reference*.
### `CreateDBSnapshot`
L'exemple de code suivant montre comment utiliser`CreateDBSnapshot`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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";
}
```
+ Pour plus de détails sur l'API, consultez [Create DBSnapshot](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/CreateDBSnapshot) in *AWS SDK pour PHP API Reference*.
### `DeleteDBInstance`
L'exemple de code suivant montre comment utiliser`DeleteDBInstance`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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";
}
```
+ Pour plus de détails sur l'API, voir [Supprimer DBInstance dans le](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/DeleteDBInstance) manuel de *référence des AWS SDK pour PHP API*.
### `DescribeDBInstances`
L'exemple de code suivant montre comment utiliser`DescribeDBInstances`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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";
}
```
+ Pour plus de détails sur l'API, voir [Description DBInstances](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/DescribeDBInstances) dans le manuel de *référence des AWS SDK pour PHP API*.
## Scénarios
### Créer un outil de suivi des éléments de travail sans serveur Aurora
L’exemple de code suivant montre comment créer une application Web qui suit des éléments de travail dans une base de données Amazon Aurora sans serveur et envoie des rapports par e-mail à l’aide d’Amazon Simple Email Service (Amazon SES).
**Kit SDK pour PHP**
Montre comment utiliser le AWS SDK pour PHP pour créer une application Web qui suit les éléments de travail dans une base de données Amazon RDS et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise une interface créée avec React.js pour interagir avec un backend RESTful PHP.
+ Intégrez une application Web React.js à AWS des services.
+ Répertoriez, ajoutez, mettez à jour et supprimez des éléments dans une table Amazon RDS.
+ Envoyez un rapport par e-mail sur les éléments de travail filtrés à l’aide d’Amazon SES.
+ Déployez et gérez des exemples de ressources à l'aide du AWS CloudFormation script inclus.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
## Exemples sans serveur
### Connexion à une base de données Amazon RDS dans une fonction Lambda
L’exemple de code suivant montre comment implémenter une fonction Lambda qui se connecte à une base de données RDS. La fonction effectue une simple requête de base de données et renvoie le résultat.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Connexion à une base de données Amazon RDS dans une fonction Lambda à l’aide de 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);
```
# Exemples Amazon RDS Data Service avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide d'Amazon RDS Data Service.
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Scénarios](#scenarios)
## Scénarios
### Créer un outil de suivi des éléments de travail sans serveur Aurora
L’exemple de code suivant montre comment créer une application Web qui suit des éléments de travail dans une base de données Amazon Aurora sans serveur et envoie des rapports par e-mail à l’aide d’Amazon Simple Email Service (Amazon SES).
**Kit SDK pour PHP**
Montre comment utiliser le AWS SDK pour PHP pour créer une application Web qui suit les éléments de travail dans une base de données Amazon RDS et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise une interface créée avec React.js pour interagir avec un backend RESTful PHP.
+ Intégrez une application Web React.js à AWS des services.
+ Répertoriez, ajoutez, mettez à jour et supprimez des éléments dans une table Amazon RDS.
+ Envoyez un rapport par e-mail sur les éléments de travail filtrés à l’aide d’Amazon SES.
+ Déployez et gérez des exemples de ressources à l'aide du AWS CloudFormation script inclus.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
# Exemples Amazon Rekognition avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide d'Amazon Rekognition.
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Scénarios](#scenarios)
## Scénarios
### Création d’une application sans serveur pour gérer des photos
L'exemple de code suivant montre comment créer une application sans serveur permettant aux utilisateurs de gérer des photos à l'aide d'étiquettes.
**Kit SDK pour PHP**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
# Exemples Amazon S3 avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide d'Amazon S3.
Les *principes de base* sont des exemples de code qui vous montrent comment effectuer les opérations essentielles au sein d’un service.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Mise en route](#get_started)
+ [Principes de base](#basics)
+ [Actions](#actions)
+ [Scénarios](#scenarios)
+ [Exemples sans serveur](#serverless_examples)
## Mise en route
### Hello Amazon S3
L'exemple de code suivant montre comment commencer à utiliser Amazon S3.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
```
+ Pour plus de détails sur l'API, reportez-vous [ListBuckets](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/ListBuckets)à la section *Référence des AWS SDK pour PHP API*.
## Principes de base
### Principes de base
L’exemple de code suivant illustre comment :
+ créer un compartiment et y charger un fichier ;
+ télécharger un objet à partir d’un compartiment ;
+ copier un objet dans le sous-dossier d’un compartiment ;
+ répertorier les objets d’un compartiment ;
+ supprimer le compartiment et tous les objets qui y figurent.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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";
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK pour 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)
## Actions
### `CopyObject`
L'exemple de code suivant montre comment utiliser`CopyObject`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples).
Copie simple d’un objet.
```
$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.");
}
```
+ Pour plus de détails sur l'API, reportez-vous [CopyObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/CopyObject)à la section *Référence des AWS SDK pour PHP API*.
### `CreateBucket`
L'exemple de code suivant montre comment utiliser`CreateBucket`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples).
Créez un compartiment.
```
$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.");
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateBucket](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/CreateBucket)à la section *Référence des AWS SDK pour PHP API*.
### `DeleteBucket`
L'exemple de code suivant montre comment utiliser`DeleteBucket`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples).
Supprimez un compartiment vide.
```
$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.");
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteBucket](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteBucket)à la section *Référence des AWS SDK pour PHP API*.
### `DeleteObject`
L'exemple de code suivant montre comment utiliser`DeleteObject`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteObject)à la section *Référence des AWS SDK pour PHP API*.
### `DeleteObjects`
L'exemple de code suivant montre comment utiliser`DeleteObjects`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples).
Supprimez un ensemble d’objets d’une liste de clés.
```
$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.");
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteObjects](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteObjects)à la section *Référence des AWS SDK pour PHP API*.
### `GetObject`
L'exemple de code suivant montre comment utiliser`GetObject`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples).
Obtenez un objet.
```
$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.");
}
```
+ Pour plus de détails sur l'API, reportez-vous [GetObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/GetObject)à la section *Référence des AWS SDK pour PHP API*.
### `ListObjectsV2`
L'exemple de code suivant montre comment utiliser`ListObjectsV2`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples).
Listez les objets dans un compartiment.
```
$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.");
}
```
+ Pour plus de détails sur l'API, voir [ListObjectsV2](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/ListObjectsV2) dans le manuel de *référence des AWS SDK pour PHP API*.
### `PutObject`
L'exemple de code suivant montre comment utiliser`PutObject`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples).
Chargez un objet dans un compartiment.
```
$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.");
}
```
+ Pour plus de détails sur l'API, reportez-vous [PutObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/PutObject)à la section *Référence des AWS SDK pour PHP API*.
## Scénarios
### Créer une URL présignée
L’exemple de code suivant montre comment créer une URL présignée pour Amazon S3 et charger un objet.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
}
}
```
### Création d’une application sans serveur pour gérer des photos
L'exemple de code suivant montre comment créer une application sans serveur permettant aux utilisateurs de gérer des photos à l'aide d'étiquettes.
**Kit SDK pour PHP**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
## Exemples sans serveur
### Invoquer une fonction lambda à partir d’un déclencheur Amazon S3
L’exemple de code suivant montre comment implémenter une fonction Lambda qui reçoit un événement déclenché par le chargement d’un objet vers un compartiment S3. La fonction extrait le nom du compartiment S3 et la clé de l’objet à partir du paramètre d’événement et appelle l’API Amazon S3 pour récupérer et consigner le type de contenu de l’objet.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda).
Consommation d’un événement S3 avec Lambda à l’aide de 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);
```
# Exemples de compartiments de répertoires S3 avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide des compartiments d'annuaire S3.
Les *principes de base* sont des exemples de code qui vous montrent comment effectuer les opérations essentielles au sein d’un service.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Principes de base](#basics)
## Principes de base
### Principes de base
L’exemple de code suivant illustre comment :
+ Configurez un VPC et un point de terminaison d’un VPC.
+ Configurez les politiques, les rôles et l’utilisateur pour qu’ils fonctionnent avec les compartiments de répertoires S3 et la classe de stockage S3 Express One Zone.
+ Créez deux clients S3.
+ Créez deux compartiments.
+ créer un objet et le copier ;
+ démontree la différence de performance ;
+ remplir les compartiments pour montrer la différence lexicographique ;
+ Invitez l’utilisateur à voir s’il souhaite nettoyer les ressources.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3/express#code-examples).
Exécutez un scénario illustrant les bases des compartiments de répertoires Amazon S3 et 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;
}
}
}
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK pour 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)
# Exemples Amazon SES avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide d'Amazon SES.
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Scénarios](#scenarios)
## Scénarios
### Créer un outil de suivi des éléments de travail sans serveur Aurora
L’exemple de code suivant montre comment créer une application Web qui suit des éléments de travail dans une base de données Amazon Aurora sans serveur et envoie des rapports par e-mail à l’aide d’Amazon Simple Email Service (Amazon SES).
**Kit SDK pour PHP**
Montre comment utiliser le AWS SDK pour PHP pour créer une application Web qui suit les éléments de travail dans une base de données Amazon RDS et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise une interface créée avec React.js pour interagir avec un backend RESTful PHP.
+ Intégrez une application Web React.js à AWS des services.
+ Répertoriez, ajoutez, mettez à jour et supprimez des éléments dans une table Amazon RDS.
+ Envoyez un rapport par e-mail sur les éléments de travail filtrés à l’aide d’Amazon SES.
+ Déployez et gérez des exemples de ressources à l'aide du AWS CloudFormation script inclus.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
# Exemples Amazon SNS avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide d'Amazon SNS.
Les *actions* sont des extraits de code de programmes plus larges et doivent être exécutées dans leur contexte. Alors que les actions vous indiquent comment appeler des fonctions de service individuelles, vous pouvez les voir en contexte dans leurs scénarios associés.
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Actions](#actions)
+ [Scénarios](#scenarios)
+ [Exemples sans serveur](#serverless_examples)
## Actions
### `CheckIfPhoneNumberIsOptedOut`
L'exemple de code suivant montre comment utiliser`CheckIfPhoneNumberIsOptedOut`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code 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());
}
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour 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).
+ Pour plus de détails sur l'API, reportez-vous [CheckIfPhoneNumberIsOptedOut](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/CheckIfPhoneNumberIsOptedOut)à la section *Référence des AWS SDK pour PHP API*.
### `ConfirmSubscription`
L'exemple de code suivant montre comment utiliser`ConfirmSubscription`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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());
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConfirmSubscription](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/ConfirmSubscription)à la section *Référence des AWS SDK pour PHP API*.
### `CreateTopic`
L'exemple de code suivant montre comment utiliser`CreateTopic`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code 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());
}
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-managing-topics.html#create-a-topic).
+ Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/CreateTopic)à la section *Référence des AWS SDK pour PHP API*.
### `DeleteTopic`
L'exemple de code suivant montre comment utiliser`DeleteTopic`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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());
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/DeleteTopic)à la section *Référence des AWS SDK pour PHP API*.
### `GetSMSAttributes`
L'exemple de code suivant montre comment utiliser`GetSMSAttributes`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code 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());
}
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#get-sms-attributes).
+ Pour plus de détails sur l'API, voir [Get SMSAttributes](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/GetSMSAttributes) in *AWS SDK pour PHP API Reference*.
### `GetTopicAttributes`
L'exemple de code suivant montre comment utiliser`GetTopicAttributes`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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());
}
```
+ Pour plus de détails sur l'API, reportez-vous [GetTopicAttributes](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/GetTopicAttributes)à la section *Référence des AWS SDK pour PHP API*.
### `ListPhoneNumbersOptedOut`
L'exemple de code suivant montre comment utiliser`ListPhoneNumbersOptedOut`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code 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());
}
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#list-opted-out-phone-numbers).
+ Pour plus de détails sur l'API, reportez-vous [ListPhoneNumbersOptedOut](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/ListPhoneNumbersOptedOut)à la section *Référence des AWS SDK pour PHP API*.
### `ListSubscriptions`
L'exemple de code suivant montre comment utiliser`ListSubscriptions`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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());
}
```
+ Pour plus de détails sur l'API, reportez-vous [ListSubscriptions](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/ListSubscriptions)à la section *Référence des AWS SDK pour PHP API*.
### `ListTopics`
L'exemple de code suivant montre comment utiliser`ListTopics`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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());
}
```
+ Pour plus de détails sur l'API, reportez-vous [ListTopics](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/ListTopics)à la section *Référence des AWS SDK pour PHP API*.
### `Publish`
L'exemple de code suivant montre comment utiliser`Publish`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code 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());
}
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour 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).
+ Pour plus d’informations sur l’API, consultez [Publier](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Publish) dans *AWS SDK pour PHP Référence de l’API*.
### `SetSMSAttributes`
L'exemple de code suivant montre comment utiliser`SetSMSAttributes`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code 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());
}
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#set-sms-attributes).
+ Pour plus de détails sur l'API, voir [Set SMSAttributes](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/SetSMSAttributes) in *AWS SDK pour PHP API Reference*.
### `SetTopicAttributes`
L'exemple de code suivant montre comment utiliser`SetTopicAttributes`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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());
}
```
+ Pour plus de détails sur l'API, reportez-vous [SetTopicAttributes](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/SetTopicAttributes)à la section *Référence des AWS SDK pour PHP API*.
### `Subscribe`
L'exemple de code suivant montre comment utiliser`Subscribe`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/sns#code-examples).
Abonnez une adresse e-mail à une rubrique.
```
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());
}
```
Abonnez un point de terminaison HTTP à une rubrique.
```
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());
}
```
+ Pour plus de détails sur l’API, consultez [Subscribe](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Subscribe) dans la *Référence des API du kit AWS SDK pour PHP *.
### `Unsubscribe`
L'exemple de code suivant montre comment utiliser`Unsubscribe`.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code 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());
}
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-subscribing-unsubscribing-topics.html#unsubscribe-from-a-topic).
+ Pour de plus amples informations sur l’API, consultez [Se désabonner](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Unsubscribe) dans *Référence de l’API AWS SDK pour PHP *.
## Scénarios
### Création d’une application sans serveur pour gérer des photos
L'exemple de code suivant montre comment créer une application sans serveur permettant aux utilisateurs de gérer des photos à l'aide d'étiquettes.
**Kit SDK pour PHP**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
### Publier un message texte SMS
L’exemple de code suivant montre comment publier des messages texte à l’aide d’Amazon SNS.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code 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());
}
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#publish-to-a-text-message-sms-message).
+ Pour plus d’informations sur l’API, consultez [Publier](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Publish) dans *AWS SDK pour PHP Référence de l’API*.
## Exemples sans serveur
### Invocation d’une fonction lambda à partir d’un déclencheur Amazon SNS
L’exemple de code suivant montre comment implémenter une fonction Lambda qui reçoit un événement déclenché par la réception de messages à partir d’une rubrique SNS. La fonction extrait les messages du paramètre d’événement et consigne le contenu de chaque message.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Utilisation d’un événement SNS avec Lambda à l’aide de 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();
```
# Exemples Amazon SQS avec le kit SDK pour PHP
Les exemples de code suivants vous montrent comment effectuer des actions et implémenter des scénarios courants à l' AWS SDK pour PHP aide d'Amazon SQS.
Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code en contexte.
**Topics**
+ [Exemples sans serveur](#serverless_examples)
## Exemples sans serveur
### Invoquer une fonction Lambda à partir d’un déclencheur Amazon SQS
L’exemple de code suivant montre comment implémenter une fonction Lambda qui reçoit un événement déclenché par la réception de messages à partir d’une file d’attente SQS. La fonction extrait les messages du paramètre d’événement et consigne le contenu de chaque message.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Consommation d’un événement SQS avec Lambda à l’aide de 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);
```
### Signalement des échecs d’articles par lots pour les fonctions Lambda à l’aide d’un déclencheur Amazon SQS
L’exemple de code suivant montre comment mettre en œuvre une réponse partielle par lots pour les fonctions Lambda qui reçoivent des événements à partir d’une file d’attente SQS. La fonction signale les défaillances échecs d’articles par lots dans la réponse, en indiquant à Lambda de réessayer ces messages ultérieurement.
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures).
Signalement des échecs d’articles par lots SQS avec Lambda à l’aide de 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);
```