文件 AWS 開發套件範例 GitHub 儲存庫中有更多可用的 [AWS SDK 範例](https://github.com/awsdocs/aws-doc-sdk-examples)。
本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 適用於 PHP 的 SDK 的程式碼範例
下列程式碼範例示範如何 適用於 PHP 的 AWS SDK 搭配 使用 AWS。
*基本概念*是程式碼範例，這些範例說明如何在服務內執行基本操作。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 AWS 服務組合來完成特定任務的程式碼範例。
有些服務包含其他範例類別，示範如何利用特定於服務的程式庫或函數。
**其他資源**
+ ** [ 適用於 PHP 的 SDK 開發人員指南 ](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/welcome.html) ** – 搭配 使用 PHP 的詳細資訊 AWS。
+ **[AWS 開發人員中心](https://aws.amazon.com/developer/code-examples/?awsf.sdk-code-examples-programming-language=programming-language%23php)** – 您可以依類別或全文檢索搜尋功能篩選的程式碼範例。
+ **[AWS SDK 範例](https://github.com/awsdocs/aws-doc-sdk-examples)** – GitHub 儲存庫使用偏好語言的完整程式碼。包含設定和執行程式碼的指示。
**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)
+ [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 資料服務](php_3_rds-data_code_examples.md)
+ [Amazon Rekognition](php_3_rekognition_code_examples.md)
+ [Amazon S3](php_3_s3_code_examples.md)
+ [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)
# 使用適用於 PHP 的 SDK 的 API Gateway 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 API Gateway 執行動作和實作常見案例。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 AWS 服務組合來完成特定任務的程式碼範例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [動作](#actions)
+ [案例](#scenarios)
## 動作
### `GetBasePathMapping`
以下程式碼範例顯示如何使用 `GetBasePathMapping`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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();
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [GetBasePathMapping](https://docs.aws.amazon.com/goto/SdkForPHPV3/apigateway-2015-07-09/GetBasePathMapping)。
### `ListBasePathMappings`
以下程式碼範例顯示如何使用 `ListBasePathMappings`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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();
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [ListBasePathMappings](https://docs.aws.amazon.com/goto/SdkForPHPV3/apigateway-2015-07-09/ListBasePathMappings)。
### `UpdateBasePathMapping`
以下程式碼範例顯示如何使用 `UpdateBasePathMapping`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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();
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [UpdateBasePathMapping](https://docs.aws.amazon.com/goto/SdkForPHPV3/apigateway-2015-07-09/UpdateBasePathMapping)。
## 案例
### 建立無伺服器應用程式來管理相片
下列程式碼範例示範如何建立無伺服器應用程式，讓使用者以標籤管理相片。
**適用於 PHP 的 SDK**
顯示如何開發照片資產管理應用程式，以便使用 Amazon Rekognition 偵測圖片中的標籤，並將其儲存以供日後擷取。
如需完整的原始碼和如何設定及執行的指示，請參閱 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager) 上的完整範例。
如要深入探索此範例的來源，請參閱 [AWS 社群](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app)上的文章。
**此範例中使用的服務**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
# 使用適用於 PHP 的 SDK 的 Aurora 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Aurora 執行動作和實作常見案例。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 AWS 服務組合來完成特定任務的程式碼範例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [案例](#scenarios)
## 案例
### 建立 Aurora 無伺服器工作項目追蹤器
下列程式碼示範如何建立一個 Web 應用程式，該應用程式會追蹤 Amazon Aurora Serverless 資料庫中的工作項目，並使用 Amazon Simple Email Service (Amazon SES) 傳送報告。
**適用於 PHP 的 SDK**
示範如何使用 適用於 PHP 的 AWS SDK 建立 Web 應用程式，以使用 Amazon Simple Email Service (Amazon SES) 追蹤 Amazon RDS 資料庫中的工作項目和電子郵件報告。這個範例使用以 React.js 建置的前端與 RESTful PHP 後端互動。
+ 將 React.js Web 應用程式與 AWS 服務整合。
+ 列出、新增、更新和刪除 Amazon RDS 資料表中的項目。
+ 使用 Amazon SES 傳送篩選工作項目的電子郵件報告。
+ 使用隨附的 AWS CloudFormation 指令碼部署和管理範例資源。
如需完整的原始碼和如何設定及執行的指示，請參閱 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker) 上的完整範例。
**此範例中使用的服務**
+ Aurora
+ Amazon RDS
+ Amazon RDS 資料服務
+ Amazon SES
# 使用適用於 PHP 的 SDK 的 Auto Scaling 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Auto Scaling 來執行動作和實作常見案例。
*基本概念*是程式碼範例，這些範例說明如何在服務內執行基本操作。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [開始使用](#get_started)
+ [基本概念](#basics)
+ [動作](#actions)
## 開始使用
### Hello Auto Scaling
下列程式碼範例示範如何開始使用 Auto Scaling。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DescribeAutoScalingGroups](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeAutoScalingGroups)。
## 基本概念
### 了解基本概念
以下程式碼範例顯示做法：
+ 以啟動範本和可用區域建立 Amazon EC2 Auto Scaling 群組，並取得有關執行中執行個體的相關資訊。
+ 啟用 Amazon CloudWatch 指標收集。
+ 更新群組所需的容量，並等待執行個體啟動。
+ 終止群組中的執行個體。
+ 列出為因應使用者請求和容量變更而發生的擴展活動。
+ 取得 CloudWatch 指標的統計資料，然後清除資源。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的下列主題。
+ [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)
## 動作
### `CreateAutoScalingGroup`
以下程式碼範例顯示如何使用 `CreateAutoScalingGroup`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
],
]);
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [CreateAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/CreateAutoScalingGroup)。
### `DeleteAutoScalingGroup`
以下程式碼範例顯示如何使用 `DeleteAutoScalingGroup`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [DeleteAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DeleteAutoScalingGroup)。
### `DescribeAutoScalingGroups`
以下程式碼範例顯示如何使用 `DescribeAutoScalingGroups`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DescribeAutoScalingGroups](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeAutoScalingGroups)。
### `DescribeAutoScalingInstances`
以下程式碼範例顯示如何使用 `DescribeAutoScalingInstances`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DescribeAutoScalingInstances](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeAutoScalingInstances)。
### `DescribeScalingActivities`
以下程式碼範例顯示如何使用 `DescribeScalingActivities`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DescribeScalingActivities](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DescribeScalingActivities)。
### `DisableMetricsCollection`
以下程式碼範例顯示如何使用 `DisableMetricsCollection`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [DisableMetricsCollection](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/DisableMetricsCollection)。
### `EnableMetricsCollection`
以下程式碼範例顯示如何使用 `EnableMetricsCollection`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [EnableMetricsCollection](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/EnableMetricsCollection)。
### `SetDesiredCapacity`
以下程式碼範例顯示如何使用 `SetDesiredCapacity`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [SetDesiredCapacity](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/SetDesiredCapacity)。
### `TerminateInstanceInAutoScalingGroup`
以下程式碼範例顯示如何使用 `TerminateInstanceInAutoScalingGroup`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [TerminateInstanceInAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/TerminateInstanceInAutoScalingGroup)。
### `UpdateAutoScalingGroup`
以下程式碼範例顯示如何使用 `UpdateAutoScalingGroup`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [UpdateAutoScalingGroup](https://docs.aws.amazon.com/goto/SdkForPHPV3/autoscaling-2011-01-01/UpdateAutoScalingGroup)。
# 使用適用於 PHP 的 SDK 的 Amazon Bedrock 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Amazon Bedrock 執行動作和實作常見案例。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [動作](#actions)
## 動作
### `ListFoundationModels`
以下程式碼範例顯示如何使用 `ListFoundationModels`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock#code-examples)中設定和執行。
列出可用的 Amazon Bedrock 基礎模型。
```
public function listFoundationModels()
{
$bedrockClient = new BedrockClient([
'region' => 'us-west-2',
'profile' => 'default'
]);
$response = $bedrockClient->listFoundationModels();
return $response['modelSummaries'];
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [ListFoundationModels](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-2023-04-20/ListFoundationModels)。
# 使用適用於 PHP 的 SDK 的 Amazon Bedrock 執行時期範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Amazon Bedrock 執行期來執行動作和實作常見案例。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 AWS 服務組合來完成特定任務的程式碼範例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [案例](#scenarios)
+ [Amazon Nova](#amazon_nova)
+ [Amazon Titan 圖像生成器](#amazon_titan_image_generator)
+ [Anthropic Claude](#anthropic_claude)
+ [Stable Diffusion](#stable_diffusion)
## 案例
### 在 Amazon Bedrock 上調用多個基礎模型
下列程式碼範例示範如何在 Amazon Bedrock 上準備並傳送提示至各種大型語言模型 (LLM)
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime/#code-examples)中設定和執行。
在 Amazon Bedrock 上調用多個 LLM。
```
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;
}
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的下列主題。
+ [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
下列程式碼範例示範如何使用 Bedrock 的 Converse API，將文字訊息傳送至 Amazon Nova。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples)中設定和執行。
使用 Bedrock 的 Converse API，將文字訊息傳送至 Amazon Nova。
```
// 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();
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [Converse](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/Converse)。
## Amazon Titan 圖像生成器
### InvokeModel
下列程式碼範例示範如何在 Amazon Bedrock 上調用 Amazon Titan Image 來產生映像。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples)中設定和執行。
使用 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;
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)。
## Anthropic Claude
### InvokeModel
下列程式碼範例示範如何使用調用模型 API，將文字訊息傳送至 Anthropic Claude。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples)中設定和執行。
調用 Anthropic Claude 2 基礎模型以產生文字。
```
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;
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)。
## Stable Diffusion
### InvokeModel
下列程式碼範例示範如何在 Amazon Bedrock 上調用 Stability.ai Stable Diffusion XL 以產生映像。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples)中設定和執行。
使用 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;
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)。
# 使用適用於 PHP 的 SDK 的 Amazon DocumentDB 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Amazon DocumentDB 執行動作和實作常見案例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [無伺服器範例](#serverless_examples)
## 無伺服器範例
### 使用 Amazon DocumentDB 觸發條件調用 Lambda 函數
以下程式碼範例示範如何實作 Lambda 函式，該函式會透過接收 DocumentDB 變更串流的記錄來接收所觸發的事件。函數會擷取 DocumentDB 承載並記下記錄內容。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 使用 Amazon DocumentDB 事件。
```
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();
```
# 使用適用於 PHP 的 SDK 的 DynamoDB 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 DynamoDB 執行動作和實作常見案例。
*基本概念*是程式碼範例，這些範例說明如何在服務內執行基本操作。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 AWS 服務組合來完成特定任務的程式碼範例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [基本概念](#basics)
+ [動作](#actions)
+ [案例](#scenarios)
+ [無伺服器範例](#serverless_examples)
## 基本概念
### 了解基本概念
以下程式碼範例顯示做法：
+ 建立可存放電影資料的資料表。
+ 放入、取得和更新資料表中的單個電影。
+ 將影片資料從範例 JSON 檔案寫入資料表。
+ 查詢特定年份發表的電影。
+ 掃描某個年份範圍內發表的電影。
+ 從資料表刪除電影，然後刪除資料表。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/dynamodb#code-examples)中設定和執行。
由於此範例使用支援檔案，請務必[閱讀 PHP 範例 README.md 檔案中的指引](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/php/README.md#prerequisites)。
```
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);
}
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的下列主題。
+ [BatchWriteItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/BatchWriteItem)
+ [CreateTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/CreateTable)
+ [DeleteItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DeleteItem)
+ [DeleteTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DeleteTable)
+ [DescribeTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DescribeTable)
+ [GetItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/GetItem)
+ [PutItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/PutItem)
+ [Query](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Query)
+ [Scan](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Scan)
+ [UpdateItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/UpdateItem)
## 動作
### `BatchExecuteStatement`
以下程式碼範例顯示如何使用 `BatchExecuteStatement`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
],
],
]);
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [BatchExecuteStatement](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/BatchExecuteStatement)。
### `BatchWriteItem`
以下程式碼範例顯示如何使用 `BatchWriteItem`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [BatchWriteItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/BatchWriteItem)。
### `CreateTable`
以下程式碼範例顯示如何使用 `CreateTable`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/dynamodb#code-examples)中設定和執行。
建立資料表。
```
$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],
]);
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [CreateTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/CreateTable)。
### `DeleteItem`
以下程式碼範例顯示如何使用 `DeleteItem`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DeleteItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DeleteItem)。
### `DeleteTable`
以下程式碼範例顯示如何使用 `DeleteTable`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
});
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [DeleteTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/DeleteTable)。
### `ExecuteStatement`
以下程式碼範例顯示如何使用 `ExecuteStatement`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [ExecuteStatement](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/ExecuteStatement)。
### `GetItem`
以下程式碼範例顯示如何使用 `GetItem`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱[《適用於 PHP 的 AWS SDK API 參考》](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/GetItem)中的 *GetItem*。
### `ListTables`
以下程式碼範例顯示如何使用 `ListTables`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的 [ListTables](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/ListTables)。
### `PutItem`
以下程式碼範例顯示如何使用 `PutItem`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [PutItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/PutItem)。
### `Query`
以下程式碼範例顯示如何使用 `Query`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [Query](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Query)。
### `Scan`
以下程式碼範例顯示如何使用 `Scan`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱[《適用於 PHP 的 AWS SDK API 參考》](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/Scan)中的 *Scan*。
### `UpdateItem`
以下程式碼範例顯示如何使用 `UpdateItem`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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
]
],
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [UpdateItem](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/UpdateItem)。
## 案例
### 建立無伺服器應用程式來管理相片
下列程式碼範例示範如何建立無伺服器應用程式，讓使用者以標籤管理相片。
**適用於 PHP 的 SDK**
顯示如何開發照片資產管理應用程式，以便使用 Amazon Rekognition 偵測圖片中的標籤，並將其儲存以供日後擷取。
如需完整的原始碼和如何設定及執行的指示，請參閱 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager) 上的完整範例。
如要深入探索此範例的來源，請參閱 [AWS 社群](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app)上的文章。
**此範例中使用的服務**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
### 使用多批 PartiQL 陳述式查詢資料表
以下程式碼範例顯示做法：
+ 透過執行多個 SELECT 陳述式取得一批項目。
+ 透過執行多個 INSERT 陳述式新增一批項目。
+ 透過執行多個 UPDATE 陳述式更新一批項目。
+ 透過執行多個 DELETE 陳述式刪除一批項目。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
],
],
]);
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [BatchExecuteStatement](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/BatchExecuteStatement)。
### 使用 PartiQL 查詢資料表
以下程式碼範例顯示做法：
+ 透過執行 SELECT 陳述式取得項目。
+ 透過執行 INSERT 陳述式新增項目。
+ 透過執行 UPDATE 陳述式更新項目。
+ 透過執行 DELETE 陳述式刪除項目。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [ExecuteStatement](https://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/ExecuteStatement)。
## 無伺服器範例
### 使用 DynamoDB 觸發條件調用 Lambda 函式
以下程式碼範例示範如何實作 Lambda 函式，該函式會透過接收 DynamoDB 串流的記錄來接收所觸發的事件。函數會擷取 DynamoDB 承載並記下記錄內容。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來使用 DynamoDB 事件。
```
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);
```
### 使用 DynamoDB 觸發條件報告 Lambda 函式的批次項目失敗
下列程式碼範例示範如何針對接收來自 DynamoDB 串流之事件的 Lambda 函式，實作部分批次回應。此函數會在回應中報告批次項目失敗，指示 Lambda 稍後重試這些訊息。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda-with-batch-item-handling)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 報告 DynamoDB 批次項目失敗。
```
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);
```
# 使用適用於 PHP 的 SDK 的 Amazon EC2 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Amazon EC2 執行動作和實作常見案例。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [動作](#actions)
## 動作
### `CreateVpc`
以下程式碼範例顯示如何使用 `CreateVpc`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的 [CreateVpc](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/CreateVpc)。
### `CreateVpcEndpoint`
以下程式碼範例顯示如何使用 `CreateVpcEndpoint`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [CreateVpcEndpoint](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/CreateVpcEndpoint)。
### `DeleteVpc`
以下程式碼範例顯示如何使用 `DeleteVpc`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DeleteVpc](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/DeleteVpc)。
### `DeleteVpcEndpoints`
以下程式碼範例顯示如何使用 `DeleteVpcEndpoints`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DeleteVpcEndpoints](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/DeleteVpcEndpoints)。
### `DescribeRouteTables`
以下程式碼範例顯示如何使用 `DescribeRouteTables`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DescribeRouteTables](https://docs.aws.amazon.com/goto/SdkForPHPV3/ec2-2016-11-15/DescribeRouteTables)。
# AWS Glue 使用適用於 PHP 的 SDK 的範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 來執行動作和實作常見案例 AWS Glue。
*基本概念*是程式碼範例，這些範例說明如何在服務內執行基本操作。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [基本概念](#basics)
+ [動作](#actions)
## 基本概念
### 了解基本概念
以下程式碼範例顯示做法：
+ 建立網路爬取公有 Amazon S3 儲存貯體的爬蟲程式，以及產生 CSV 格式中繼資料的資料庫。
+ 列出 中資料庫和資料表的相關資訊 AWS Glue Data Catalog。
+ 建立從 S3 儲存貯體中擷取 CSV 資料的任務、轉換資料，以及將 JSON 格式的輸出載入至另一個 S3 儲存貯體。
+ 列出任務執行的相關資訊、檢視已轉換的資料以及清除資源。
如需詳細資訊，請參閱[教學課程： AWS Glue Studio 入門](https://docs.aws.amazon.com/glue/latest/ug/tutorial-create-job.html)。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的下列主題。
+ [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)
## 動作
### `CreateCrawler`
以下程式碼範例顯示如何使用 `CreateCrawler`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]]
],
]);
});
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [CreateCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/CreateCrawler)。
### `CreateJob`
以下程式碼範例顯示如何使用 `CreateJob`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [CreateJob](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/CreateJob)。
### `DeleteCrawler`
以下程式碼範例顯示如何使用 `DeleteCrawler`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [DeleteCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteCrawler)。
### `DeleteDatabase`
以下程式碼範例顯示如何使用 `DeleteDatabase`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [DeleteDatabase](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteDatabase)。
### `DeleteJob`
以下程式碼範例顯示如何使用 `DeleteJob`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [DeleteJob](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteJob)。
### `DeleteTable`
以下程式碼範例顯示如何使用 `DeleteTable`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [DeleteTable](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/DeleteTable)。
### `GetCrawler`
以下程式碼範例顯示如何使用 `GetCrawler`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
});
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [GetCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetCrawler)。
### `GetDatabase`
以下程式碼範例顯示如何使用 `GetDatabase`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
});
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [GetDatabase](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetDatabase)。
### `GetJobRun`
以下程式碼範例顯示如何使用 `GetJobRun`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [GetJobRun](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetJobRun)。
### `GetJobRuns`
以下程式碼範例顯示如何使用 `GetJobRuns`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [GetJobRuns](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetJobRuns)。
### `GetTables`
以下程式碼範例顯示如何使用 `GetTables`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [GetTables](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/GetTables)。
### `ListJobs`
以下程式碼範例顯示如何使用 `ListJobs`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [ListJobs](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/ListJobs)。
### `StartCrawler`
以下程式碼範例顯示如何使用 `StartCrawler`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考**》中的 [StartCrawler](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/StartCrawler)。
### `StartJobRun`
以下程式碼範例顯示如何使用 `StartJobRun`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
],
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考**》中的 [StartJobRun](https://docs.aws.amazon.com/goto/SdkForPHPV3/glue-2017-03-31/StartJobRun)。
# 使用適用於 PHP 的 SDK 的 IAM 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 IAM 執行動作和實作常見案例。
*基本概念*是程式碼範例，這些範例說明如何在服務內執行基本操作。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [基本概念](#basics)
+ [動作](#actions)
## 基本概念
### 了解基本概念
下列程式碼範例示範如何建立使用者並擔任角色。
**警告**
為避免安全風險，在開發專用軟體或使用真實資料時，請勿使用 IAM 使用者進行身分驗證。相反地，搭配使用聯合功能和身分提供者，例如 [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html)。
+ 建立沒有許可的使用者。
+ 建立一個可授予許可的角色，以列出帳戶的 Amazon S3 儲存貯體。
+ 新增政策，讓使用者擔任該角色。
+ 使用暫時憑證，擔任角色並列出 S3 儲存貯體，然後清理資源。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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";
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的下列主題。
+ [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)
## 動作
### `AttachRolePolicy`
以下程式碼範例顯示如何使用 `AttachRolePolicy`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
});
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [AttachRolePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/AttachRolePolicy)。
### `CreatePolicy`
以下程式碼範例顯示如何使用 `CreatePolicy`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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'];
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [CreatePolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreatePolicy)。
### `CreateRole`
以下程式碼範例顯示如何使用 `CreateRole`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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'];
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [CreateRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateRole)。
### `CreateServiceLinkedRole`
以下程式碼範例顯示如何使用 `CreateServiceLinkedRole`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [CreateServiceLinkedRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateServiceLinkedRole)。
### `CreateUser`
以下程式碼範例顯示如何使用 `CreateUser`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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'];
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [CreateUser](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/CreateUser)。
### `GetAccountPasswordPolicy`
以下程式碼範例顯示如何使用 `GetAccountPasswordPolicy`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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();
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [GetAccountPasswordPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/GetAccountPasswordPolicy)。
### `GetPolicy`
以下程式碼範例顯示如何使用 `GetPolicy`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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]);
});
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [GetPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/GetPolicy)。
### `GetRole`
以下程式碼範例顯示如何使用 `GetRole`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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]);
});
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [GetRole](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/GetRole)。
### `ListAttachedRolePolicies`
以下程式碼範例顯示如何使用 `ListAttachedRolePolicies`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [ListAttachedRolePolicies](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListAttachedRolePolicies)。
### `ListGroups`
以下程式碼範例顯示如何使用 `ListGroups`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [ListGroups](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListGroups)。
### `ListPolicies`
以下程式碼範例顯示如何使用 `ListPolicies`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [ListPolicies](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListPolicies)。
### `ListRolePolicies`
以下程式碼範例顯示如何使用 `ListRolePolicies`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
});
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [ListRolePolicies](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListRolePolicies)。
### `ListRoles`
以下程式碼範例顯示如何使用 `ListRoles`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [ListRoles](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListRoles)。
### `ListSAMLProviders`
以下程式碼範例顯示如何使用 `ListSAMLProviders`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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();
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [ListSAMLProviders](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListSAMLProviders)。
### `ListUsers`
以下程式碼範例顯示如何使用 `ListUsers`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API Reference* 中的 [ListUsers](https://docs.aws.amazon.com/goto/SdkForPHPV3/iam-2010-05-08/ListUsers)。
# 使用適用於 PHP 的 SDK 的 Kinesis 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Kinesis 執行動作和實作常見案例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [無伺服器範例](#serverless_examples)
## 無伺服器範例
### 使用 Kinesis 觸發條件調用 Lambda 函數
以下程式碼範例示範如何實作 Lambda 函式，該函式會透過接收 Kinesis 串流的記錄來接收所觸發的事件。此函數會擷取 Kinesis 承載、從 Base64 解碼，並記錄記錄內容。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來使用 Kinesis 事件。
```
// 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);
```
### 使用 Kinesis 觸發條件報告 Lambda 函數的批次項目失敗
下列程式碼範例示範如何針對接收來自 Kinesis 串流之事件的 Lambda 函式，實作部分批次回應。此函數會在回應中報告批次項目失敗，指示 Lambda 稍後重試這些訊息。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda-with-batch-item-handling)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來報告 Kinesis 批次項目失敗。
```
// 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 使用適用於 PHP 的 SDK 的範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 來執行動作和實作常見案例 AWS KMS。
*基本概念*是程式碼範例，這些範例說明如何在服務內執行基本操作。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [開始使用](#get_started)
+ [基本概念](#basics)
+ [動作](#actions)
## 開始使用
### 您好 AWS KMS
下列程式碼範例示範如何開始使用 AWS Key Management Service。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [ListKeys](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListKeys)。
## 基本概念
### 了解基本概念
以下程式碼範例顯示做法：
+ 建立 KMS 金鑰。
+ 列出您帳戶的 KMS 金鑰，並取得其詳細資訊。
+ 啟用和停用 KMS 金鑰。
+ 產生可用於用戶端加密的對稱資料金鑰。
+ 產生用於數位簽署資料的非對稱金鑰。
+ 標籤索引鍵。
+ 刪除 KMS 金鑰。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的下列主題。
+ [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)
+ [解密](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)
+ [加密](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)
+ [符號](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)
## 動作
### `CreateAlias`
以下程式碼範例顯示如何使用 `CreateAlias`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [CreateAlias](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateAlias)。
### `CreateGrant`
以下程式碼範例顯示如何使用 `CreateGrant`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [CreateGrant](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateGrant)。
### `CreateKey`
以下程式碼範例顯示如何使用 `CreateKey`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [CreateKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/CreateKey)。
### `Decrypt`
以下程式碼範例顯示如何使用 `Decrypt`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [Decrypt](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Decrypt)。
### `DeleteAlias`
以下程式碼範例顯示如何使用 `DeleteAlias`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DeleteAlias](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/DeleteAlias)。
### `DescribeKey`
以下程式碼範例顯示如何使用 `DescribeKey`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DescribeKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/DescribeKey)。
### `DisableKey`
以下程式碼範例顯示如何使用 `DisableKey`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DisableKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/DisableKey)。
### `EnableKey`
以下程式碼範例顯示如何使用 `EnableKey`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [EnableKey](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/EnableKey)。
### `Encrypt`
以下程式碼範例顯示如何使用 `Encrypt`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [Encrypt](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Encrypt)。
### `ListAliases`
以下程式碼範例顯示如何使用 `ListAliases`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [ListAliases](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListAliases)。
### `ListGrants`
以下程式碼範例顯示如何使用 `ListGrants`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [ListGrants](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListGrants)。
### `ListKeys`
以下程式碼範例顯示如何使用 `ListKeys`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [ListKeys](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ListKeys)。
### `PutKeyPolicy`
以下程式碼範例顯示如何使用 `PutKeyPolicy`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [PutKeyPolicy](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/PutKeyPolicy)。
### `RevokeGrant`
以下程式碼範例顯示如何使用 `RevokeGrant`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [RevokeGrant](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/RevokeGrant)。
### `ScheduleKeyDeletion`
以下程式碼範例顯示如何使用 `ScheduleKeyDeletion`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [ScheduleKeyDeletion](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/ScheduleKeyDeletion)。
### `Sign`
以下程式碼範例顯示如何使用 `Sign`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [Sign](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Sign)。
### `TagResource`
以下程式碼範例顯示如何使用 `TagResource`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的 [TagResource](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/TagResource)。
# 使用適用於 PHP 的 SDK 的 Lambda 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Lambda 來執行動作和實作常見案例。
*基本概念*是程式碼範例，這些範例說明如何在服務內執行基本操作。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 AWS 服務組合來完成特定任務的程式碼範例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [基本概念](#basics)
+ [動作](#actions)
+ [案例](#scenarios)
+ [無伺服器範例](#serverless_examples)
## 基本概念
### 了解基本概念
以下程式碼範例顯示做法：
+ 建立 IAM 角色和 Lambda 函數，然後上傳處理常式程式碼。
+ 調用具有單一參數的函數並取得結果。
+ 更新函數程式碼並使用環境變數進行設定。
+ 調用具有新參數的函數並取得結果。顯示傳回的執行日誌。
+ 列出您帳戶的函數，然後清理相關資源。
如需詳細資訊，請參閱[使用主控台建立 Lambda 函數](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html)。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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";
}
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的下列主題。
+ [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)
## 動作
### `CreateFunction`
以下程式碼範例顯示如何使用 `CreateFunction`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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",
]);
});
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的「[CreateFunction](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/CreateFunction)」。
### `DeleteFunction`
以下程式碼範例顯示如何使用 `DeleteFunction`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [DeleteFunction](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/DeleteFunction)。
### `GetFunction`
以下程式碼範例顯示如何使用 `GetFunction`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [GetFunction](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/GetFunction)。
### `Invoke`
以下程式碼範例顯示如何使用 `Invoke`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [Invoke](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/Invoke)。
### `ListFunctions`
以下程式碼範例顯示如何使用 `ListFunctions`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [ListFunctions](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/ListFunctions)。
### `UpdateFunctionCode`
以下程式碼範例顯示如何使用 `UpdateFunctionCode`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [UpdateFunctionCode](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/UpdateFunctionCode)。
### `UpdateFunctionConfiguration`
以下程式碼範例顯示如何使用 `UpdateFunctionConfiguration`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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,
]);
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [UpdateFunctionConfiguration](https://docs.aws.amazon.com/goto/SdkForPHPV3/lambda-2015-03-31/UpdateFunctionConfiguration)。
## 案例
### 建立無伺服器應用程式來管理相片
下列程式碼範例示範如何建立無伺服器應用程式，讓使用者以標籤管理相片。
**適用於 PHP 的 SDK**
顯示如何開發照片資產管理應用程式，以便使用 Amazon Rekognition 偵測圖片中的標籤，並將其儲存以供日後擷取。
如需完整的原始碼和如何設定及執行的指示，請參閱 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager) 上的完整範例。
如要深入探索此範例的來源，請參閱 [AWS 社群](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app)上的文章。
**此範例中使用的服務**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
## 無伺服器範例
### 連線至 Lambda 函數中的 Amazon RDS 資料庫
以下程式碼範例示範如何實作連線至 RDS 資料庫的 Lambda 函式。該函數會提出簡單的資料庫請求並傳回結果。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam)儲存庫中設定和執行。
使用 PHP 連線至 Lambda 函數中的 Amazon RDS 資料庫。
```
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);
```
### 使用 Kinesis 觸發條件調用 Lambda 函數
以下程式碼範例示範如何實作 Lambda 函式，該函式會透過接收 Kinesis 串流的記錄來接收所觸發的事件。此函數會擷取 Kinesis 承載、從 Base64 解碼，並記錄記錄內容。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來使用 Kinesis 事件。
```
// 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);
```
### 使用 DynamoDB 觸發條件調用 Lambda 函式
以下程式碼範例示範如何實作 Lambda 函式，該函式會透過接收 DynamoDB 串流的記錄來接收所觸發的事件。函數會擷取 DynamoDB 承載並記下記錄內容。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來使用 DynamoDB 事件。
```
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);
```
### 使用 Amazon DocumentDB 觸發條件調用 Lambda 函數
以下程式碼範例示範如何實作 Lambda 函式，該函式會透過接收 DocumentDB 變更串流的記錄來接收所觸發的事件。函數會擷取 DocumentDB 承載並記下記錄內容。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 使用 Amazon DocumentDB 事件。
```
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();
```
### 使用 Amazon MSK 觸發條件調用 Lambda 函數
以下程式碼範例示範如何實作 Lambda 函式，該函式會透過接收 Amazon MSK 叢集的記錄來接收所觸發的事件。函數會擷取 MSK 承載並記下記錄內容。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來取用 Amazon MSK 事件。
```
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);
```
### 使用 Amazon S3 觸發條件調用 Lambda 函數
下列程式碼範例示範如何實作 Lambda 函式，該函式接收透過上傳物件至 S3 儲存貯體時所觸發的事件。此函數會從事件參數擷取 S3 儲存貯體名稱和物件金鑰，並呼叫 Amazon S3 API 以擷取和記錄物件的內容類型。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來使用 S3 事件。
```
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);
```
### 使用 Amazon SNS 觸發條件調用 Lambda 函數
下列程式碼範例示範如何實作 Lambda 函式，該函式會透過接收 SNS 主題的訊息來接收所觸發的事件。函數會從事件參數擷取訊息，並記錄每一則訊息的內容。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來使用 SNS 事件。
```
// 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();
```
### 使用 Amazon SQS 觸發條件調用 Lambda 函數
下列程式碼範例示範如何實作 Lambda 函式，該函式會透過接收 SQS 佇列的訊息來接收所觸發的事件。函數會從事件參數擷取訊息，並記錄每一則訊息的內容。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來使用 SQS 事件。
```
// 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);
```
### 使用 Kinesis 觸發條件報告 Lambda 函數的批次項目失敗
下列程式碼範例示範如何針對接收來自 Kinesis 串流之事件的 Lambda 函式，實作部分批次回應。此函數會在回應中報告批次項目失敗，指示 Lambda 稍後重試這些訊息。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-kinesis-to-lambda-with-batch-item-handling)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來報告 Kinesis 批次項目失敗。
```
// 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);
```
### 使用 DynamoDB 觸發條件報告 Lambda 函式的批次項目失敗
下列程式碼範例示範如何針對接收來自 DynamoDB 串流之事件的 Lambda 函式，實作部分批次回應。此函數會在回應中報告批次項目失敗，指示 Lambda 稍後重試這些訊息。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda-with-batch-item-handling)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 報告 DynamoDB 批次項目失敗。
```
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);
```
### 使用 Amazon SQS 觸發條件報告 Lambda 函數的批次項目失敗
下列程式碼範例示範如何為接收從 SQS 佇列接收事件的 Lambda 函式，實作部分批次回應。此函數會在回應中報告批次項目失敗，指示 Lambda 稍後重試這些訊息。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 報告 SQS 批次項目失敗。
```
// 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);
```
# 使用適用於 PHP 的 SDK 的 Amazon MSK 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Amazon MSK 執行動作和實作常見案例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [無伺服器範例](#serverless_examples)
## 無伺服器範例
### 使用 Amazon MSK 觸發條件調用 Lambda 函數
以下程式碼範例示範如何實作 Lambda 函式，該函式會透過接收 Amazon MSK 叢集的記錄來接收所觸發的事件。函數會擷取 MSK 承載並記下記錄內容。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-msk-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來取用 Amazon MSK 事件。
```
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);
```
# 使用適用於 PHP 的 SDK 的 Amazon RDS 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Amazon RDS 執行動作和實作常見案例。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 AWS 服務組合來完成特定任務的程式碼範例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [動作](#actions)
+ [案例](#scenarios)
+ [無伺服器範例](#serverless_examples)
## 動作
### `CreateDBInstance`
以下程式碼範例顯示如何使用 `CreateDBInstance`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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";
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [CreateDBInstance](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/CreateDBInstance)。
### `CreateDBSnapshot`
以下程式碼範例顯示如何使用 `CreateDBSnapshot`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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";
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [CreateDBSnapshot](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/CreateDBSnapshot)。
### `DeleteDBInstance`
以下程式碼範例顯示如何使用 `DeleteDBInstance`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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";
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DeleteDBInstance](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/DeleteDBInstance)。
### `DescribeDBInstances`
以下程式碼範例顯示如何使用 `DescribeDBInstances`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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";
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DescribeDBInstances](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/DescribeDBInstances)。
## 案例
### 建立 Aurora 無伺服器工作項目追蹤器
下列程式碼示範如何建立一個 Web 應用程式，該應用程式會追蹤 Amazon Aurora Serverless 資料庫中的工作項目，並使用 Amazon Simple Email Service (Amazon SES) 傳送報告。
**適用於 PHP 的 SDK**
示範如何使用 適用於 PHP 的 AWS SDK 建立 Web 應用程式，以使用 Amazon Simple Email Service (Amazon SES) 追蹤 Amazon RDS 資料庫中的工作項目和電子郵件報告。這個範例使用以 React.js 建置的前端與 RESTful PHP 後端互動。
+ 將 React.js Web 應用程式與 AWS 服務整合。
+ 列出、新增、更新和刪除 Amazon RDS 資料表中的項目。
+ 使用 Amazon SES 傳送篩選工作項目的電子郵件報告。
+ 使用隨附的 AWS CloudFormation 指令碼部署和管理範例資源。
如需完整的原始碼和如何設定及執行的指示，請參閱 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker) 上的完整範例。
**此範例中使用的服務**
+ Aurora
+ Amazon RDS
+ Amazon RDS 資料服務
+ Amazon SES
## 無伺服器範例
### 連線至 Lambda 函數中的 Amazon RDS 資料庫
以下程式碼範例示範如何實作連線至 RDS 資料庫的 Lambda 函式。該函數會提出簡單的資料庫請求並傳回結果。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam)儲存庫中設定和執行。
使用 PHP 連線至 Lambda 函數中的 Amazon RDS 資料庫。
```
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);
```
# 使用適用於 PHP 的 SDK 的 Amazon RDS Data Service 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Amazon RDS Data Service 執行動作和實作常見案例。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 AWS 服務組合來完成特定任務的程式碼範例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [案例](#scenarios)
## 案例
### 建立 Aurora 無伺服器工作項目追蹤器
下列程式碼示範如何建立一個 Web 應用程式，該應用程式會追蹤 Amazon Aurora Serverless 資料庫中的工作項目，並使用 Amazon Simple Email Service (Amazon SES) 傳送報告。
**適用於 PHP 的 SDK**
示範如何使用 適用於 PHP 的 AWS SDK 建立 Web 應用程式，以使用 Amazon Simple Email Service (Amazon SES) 追蹤 Amazon RDS 資料庫中的工作項目和電子郵件報告。這個範例使用以 React.js 建置的前端與 RESTful PHP 後端互動。
+ 將 React.js Web 應用程式與 AWS 服務整合。
+ 列出、新增、更新和刪除 Amazon RDS 資料表中的項目。
+ 使用 Amazon SES 傳送篩選工作項目的電子郵件報告。
+ 使用隨附的 AWS CloudFormation 指令碼部署和管理範例資源。
如需完整的原始碼和如何設定及執行的指示，請參閱 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker) 上的完整範例。
**此範例中使用的服務**
+ Aurora
+ Amazon RDS
+ Amazon RDS 資料服務
+ Amazon SES
# 使用適用於 PHP 的 SDK 的 Amazon Rekognition 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Amazon Rekognition 執行動作和實作常見案例。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 AWS 服務組合來完成特定任務的程式碼範例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [案例](#scenarios)
## 案例
### 建立無伺服器應用程式來管理相片
下列程式碼範例示範如何建立無伺服器應用程式，讓使用者以標籤管理相片。
**適用於 PHP 的 SDK**
顯示如何開發照片資產管理應用程式，以便使用 Amazon Rekognition 偵測圖片中的標籤，並將其儲存以供日後擷取。
如需完整的原始碼和如何設定及執行的指示，請參閱 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager) 上的完整範例。
如要深入探索此範例的來源，請參閱 [AWS 社群](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app)上的文章。
**此範例中使用的服務**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
# 使用適用於 PHP 的 SDK 的 Amazon S3 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Amazon S3 執行動作和實作常見案例。
*基本概念*是程式碼範例，這些範例說明如何在服務內執行基本操作。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 AWS 服務組合來完成特定任務的程式碼範例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [開始使用](#get_started)
+ [基本概念](#basics)
+ [動作](#actions)
+ [案例](#scenarios)
+ [無伺服器範例](#serverless_examples)
## 開始使用
### 您好 Amazon S3
下列程式碼範例說明如何開始使用 Amazon S3。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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);
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [ListBuckets](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/ListBuckets)。
## 基本概念
### 了解基本概念
以下程式碼範例顯示做法：
+ 建立儲存貯體並上傳檔案到該儲存貯體。
+ 從儲存貯體下載物件。
+ 將物件複製至儲存貯體中的子文件夾。
+ 列出儲存貯體中的物件。
+ 刪除儲存貯體物件和該儲存貯體。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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";
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的下列主題。
+ [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)
## 動作
### `CopyObject`
以下程式碼範例顯示如何使用 `CopyObject`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples)中設定和執行。
簡單複製物件。
```
$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.");
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [CopyObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/CopyObject)。
### `CreateBucket`
以下程式碼範例顯示如何使用 `CreateBucket`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples)中設定和執行。
建立儲存貯體。
```
$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.");
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [CreateBucket](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/CreateBucket)。
### `DeleteBucket`
以下程式碼範例顯示如何使用 `DeleteBucket`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples)中設定和執行。
刪除空的儲存貯體。
```
$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.");
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [DeleteBucket](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteBucket)。
### `DeleteObject`
以下程式碼範例顯示如何使用 `DeleteObject`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [DeleteObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteObject)。
### `DeleteObjects`
以下程式碼範例顯示如何使用 `DeleteObjects`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples)中設定和執行。
刪除金鑰清單中一整組物件。
```
$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.");
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [DeleteObjects](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/DeleteObjects)。
### `GetObject`
以下程式碼範例顯示如何使用 `GetObject`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples)中設定和執行。
取得物件。
```
$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.");
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [GetObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/GetObject)。
### `ListObjectsV2`
以下程式碼範例顯示如何使用 `ListObjectsV2`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples)中設定和執行。
列出儲存貯體中的物件。
```
$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.");
}
```
+ 如需 API 詳細資訊，請參閱《*適用於 PHP 的 AWS SDK API 參考*》中的 [ListObjectsV2](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/ListObjectsV2)。
### `PutObject`
以下程式碼範例顯示如何使用 `PutObject`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3#code-examples)中設定和執行。
將物件上傳至儲存貯體。
```
$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.");
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的 [PutObject](https://docs.aws.amazon.com/goto/SdkForPHPV3/s3-2006-03-01/PutObject)。
## 案例
### 建立預先簽章 URL
下列程式碼範例示範如何建立適用於 Amazon S3 預先簽署的 URL，並上傳物件。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
}
}
}
```
### 建立無伺服器應用程式來管理相片
下列程式碼範例示範如何建立無伺服器應用程式，讓使用者以標籤管理相片。
**適用於 PHP 的 SDK**
顯示如何開發照片資產管理應用程式，以便使用 Amazon Rekognition 偵測圖片中的標籤，並將其儲存以供日後擷取。
如需完整的原始碼和如何設定及執行的指示，請參閱 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager) 上的完整範例。
如要深入探索此範例的來源，請參閱 [AWS 社群](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app)上的文章。
**此範例中使用的服務**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
## 無伺服器範例
### 使用 Amazon S3 觸發條件調用 Lambda 函數
下列程式碼範例示範如何實作 Lambda 函式，該函式接收透過上傳物件至 S3 儲存貯體時所觸發的事件。此函數會從事件參數擷取 S3 儲存貯體名稱和物件金鑰，並呼叫 Amazon S3 API 以擷取和記錄物件的內容類型。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-s3-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來使用 S3 事件。
```
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);
```
# 使用適用於 PHP 的 SDK 的 S3 目錄儲存貯體範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 S3 Directory Buckets 來執行動作和實作常見案例。
*基本概念*是程式碼範例，這些範例說明如何在服務內執行基本操作。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [基本概念](#basics)
## 基本概念
### 了解基本概念
以下程式碼範例顯示做法：
+ 設定 VPC 和 VPC 端點。
+ 設定政策、角色和使用者，以使用 S3 目錄儲存貯體和 S3 Express One Zone 儲存類別。
+ 建立兩個 S3 用戶端。
+ 建立兩個儲存貯體。
+ 建立物件並進行複製。
+ 展示效能差異。
+ 填入儲存貯體以顯示字典序的差異。
+ 提示使用者查看他們是否要清除資源。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [AWS 程式碼範例儲存庫](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/s3/express#code-examples)中設定和執行。
執行展示 Amazon S3 目錄儲存貯體和 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;
}
}
}
```
+ 如需 API 詳細資訊，請參閱*《適用於 PHP 的 AWS SDK API 參考》*中的下列主題。
+ [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)
# 使用適用於 PHP 的 SDK 的 Amazon SES 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Amazon SES 執行動作和實作常見案例。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 AWS 服務組合來完成特定任務的程式碼範例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [案例](#scenarios)
## 案例
### 建立 Aurora 無伺服器工作項目追蹤器
下列程式碼示範如何建立一個 Web 應用程式，該應用程式會追蹤 Amazon Aurora Serverless 資料庫中的工作項目，並使用 Amazon Simple Email Service (Amazon SES) 傳送報告。
**適用於 PHP 的 SDK**
示範如何使用 適用於 PHP 的 AWS SDK 建立 Web 應用程式，以使用 Amazon Simple Email Service (Amazon SES) 追蹤 Amazon RDS 資料庫中的工作項目和電子郵件報告。這個範例使用以 React.js 建置的前端與 RESTful PHP 後端互動。
+ 將 React.js Web 應用程式與 AWS 服務整合。
+ 列出、新增、更新和刪除 Amazon RDS 資料表中的項目。
+ 使用 Amazon SES 傳送篩選工作項目的電子郵件報告。
+ 使用隨附的 AWS CloudFormation 指令碼部署和管理範例資源。
如需完整的原始碼和如何設定及執行的指示，請參閱 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker) 上的完整範例。
**此範例中使用的服務**
+ Aurora
+ Amazon RDS
+ Amazon RDS 資料服務
+ Amazon SES
# 使用適用於 PHP 的 SDK 的 Amazon SNS 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Amazon SNS 執行動作和實作常見案例。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 AWS 服務組合來完成特定任務的程式碼範例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [動作](#actions)
+ [案例](#scenarios)
+ [無伺服器範例](#serverless_examples)
## 動作
### `CheckIfPhoneNumberIsOptedOut`
以下程式碼範例顯示如何使用 `CheckIfPhoneNumberIsOptedOut`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需詳細資訊，請參閱《[適用於 PHP 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#check-if-a-phone-number-has-opted-out)》。
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的 [CheckIfPhoneNumberIsOptedOut](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/CheckIfPhoneNumberIsOptedOut)。
### `ConfirmSubscription`
以下程式碼範例顯示如何使用 `ConfirmSubscription`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的 [ConfirmSubscription](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/ConfirmSubscription)。
### `CreateTopic`
以下程式碼範例顯示如何使用 `CreateTopic`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需詳細資訊，請參閱《[適用於 PHP 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-managing-topics.html#create-a-topic)》。
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [CreateTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/CreateTopic)。
### `DeleteTopic`
以下程式碼範例顯示如何使用 `DeleteTopic`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的 [DeleteTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/DeleteTopic)。
### `GetSMSAttributes`
以下程式碼範例顯示如何使用 `GetSMSAttributes`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需詳細資訊，請參閱《[適用於 PHP 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#get-sms-attributes)》。
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的 [GetSMSAttributes](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/GetSMSAttributes)。
### `GetTopicAttributes`
以下程式碼範例顯示如何使用 `GetTopicAttributes`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的 [GetTopicAttributes](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/GetTopicAttributes)。
### `ListPhoneNumbersOptedOut`
以下程式碼範例顯示如何使用 `ListPhoneNumbersOptedOut`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需詳細資訊，請參閱《[適用於 PHP 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#list-opted-out-phone-numbers)》。
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的 [ListPhoneNumbersOptedOut](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/ListPhoneNumbersOptedOut)。
### `ListSubscriptions`
以下程式碼範例顯示如何使用 `ListSubscriptions`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的 [ListSubscriptions](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/ListSubscriptions)。
### `ListTopics`
以下程式碼範例顯示如何使用 `ListTopics`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的 [ListTopics](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/ListTopics)。
### `Publish`
以下程式碼範例顯示如何使用 `Publish`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需詳細資訊，請參閱《[適用於 PHP 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-subscribing-unsubscribing-topics.html#publish-a-message-to-an-sns-topic)》。
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的[發佈](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Publish)。
### `SetSMSAttributes`
以下程式碼範例顯示如何使用 `SetSMSAttributes`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需詳細資訊，請參閱《[適用於 PHP 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#set-sms-attributes)》。
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的 [SetSMSAttributes](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/SetSMSAttributes)。
### `SetTopicAttributes`
以下程式碼範例顯示如何使用 `SetTopicAttributes`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的 [SetTopicAttributes](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/SetTopicAttributes)。
### `Subscribe`
以下程式碼範例顯示如何使用 `Subscribe`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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;
/**
* 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());
}
```
將 HTTP 端點訂閱至主題。
```
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());
}
```
+ 如需 API 詳細資訊，請參閱《適用於 PHP 的 AWS SDK API 參考》**中的[訂閱](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Subscribe)。
### `Unsubscribe`
以下程式碼範例顯示如何使用 `Unsubscribe`。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需詳細資訊，請參閱《[適用於 PHP 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-subscribing-unsubscribing-topics.html#unsubscribe-from-a-topic)》。
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的[取消訂閱](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Unsubscribe)。
## 案例
### 建立無伺服器應用程式來管理相片
下列程式碼範例示範如何建立無伺服器應用程式，讓使用者以標籤管理相片。
**適用於 PHP 的 SDK**
顯示如何開發照片資產管理應用程式，以便使用 Amazon Rekognition 偵測圖片中的標籤，並將其儲存以供日後擷取。
如需完整的原始碼和如何設定及執行的指示，請參閱 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager) 上的完整範例。
如要深入探索此範例的來源，請參閱 [AWS 社群](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app)上的文章。
**此範例中使用的服務**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
### 發布簡訊
下列程式碼範例示範如何使用 Amazon SNS 發佈訊息。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在 [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());
}
```
+ 如需詳細資訊，請參閱《[適用於 PHP 的 AWS SDK 開發人員指南](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-sending-sms.html#publish-to-a-text-message-sms-message)》。
+ 如需 API 詳細資訊，請參閱 *適用於 PHP 的 AWS SDK API 參考*中的[發佈](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Publish)。
## 無伺服器範例
### 使用 Amazon SNS 觸發條件調用 Lambda 函數
下列程式碼範例示範如何實作 Lambda 函式，該函式會透過接收 SNS 主題的訊息來接收所觸發的事件。函數會從事件參數擷取訊息，並記錄每一則訊息的內容。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來使用 SNS 事件。
```
// 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();
```
# 使用適用於 PHP 的 SDK 的 Amazon SQS 範例
下列程式碼範例示範如何使用 適用於 PHP 的 AWS SDK 搭配 Amazon SQS 來執行動作和實作常見案例。
每個範例均包含完整原始碼的連結，您可在連結中找到如何設定和執行內容中程式碼的相關指示。
**Topics**
+ [無伺服器範例](#serverless_examples)
## 無伺服器範例
### 使用 Amazon SQS 觸發條件調用 Lambda 函數
下列程式碼範例示範如何實作 Lambda 函式，該函式會透過接收 SQS 佇列的訊息來接收所觸發的事件。函數會從事件參數擷取訊息，並記錄每一則訊息的內容。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 來使用 SQS 事件。
```
// 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);
```
### 使用 Amazon SQS 觸發條件報告 Lambda 函數的批次項目失敗
下列程式碼範例示範如何為接收從 SQS 佇列接收事件的 Lambda 函式，實作部分批次回應。此函數會在回應中報告批次項目失敗，指示 Lambda 稍後重試這些訊息。
**適用於 PHP 的 SDK**
GitHub 上提供更多範例。尋找完整範例，並了解如何在[無伺服器範例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures)儲存庫中設定和執行。
使用 PHP 搭配 Lambda 報告 SQS 批次項目失敗。
```
// 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);
```