2023-04-28 15:56:27 -07:00
< ? php
2024-01-31 08:10:26 -07:00
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
2023-04-28 15:56:27 -07:00
/**
* Purpose
* Shows how to use the AWS SDK for PHP with Amazon EC2 Auto Scaling to:
* 1. Create and run a crawler that crawls a public Amazon Simple Storage
* Service (Amazon S3) bucket and generates a metadata database that describes the
* CSV-formatted data it finds.
* 2. List information about databases and tables in your Amazon EC2 Auto Scaling Data Catalog.
* 3. Create and run a job that extracts CSV data from the source S3 bucket,
* transforms it by removing and renaming fields, and loads JSON-formatted output into
* another S3 bucket.
* 4. List information about job runs and view some of the transformed data.
* 5. Delete all resources created by the example.
**/
2024-01-31 08:10:26 -07:00
// snippet-start:[php.example_code.auto-scaling.basics.scenario]
2023-04-28 15:56:27 -07:00
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 ()
{
2023-05-12 05:28:46 -07:00
echo ( " \n " );
2023-04-28 15:56:27 -07:00
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 " ;
2024-01-31 08:10:26 -07:00
$launchTemplate = $this -> ec2Client -> createLaunchTemplate (
[
2023-04-28 15:56:27 -07:00
'LaunchTemplateName' => $this -> templateName ,
'LaunchTemplateData' => [
'InstanceType' => $instanceType ,
'ImageId' => $amiId ,
]
2024-01-31 08:10:26 -07:00
]
);
2023-04-28 15:56:27 -07:00
/**
* 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' ],
],
];
2024-01-31 08:10:26 -07:00
$metrics = $this -> cloudWatchClient -> listMetrics (
[
2023-04-28 15:56:27 -07:00
'Dimensions' => $metricsDimensions ,
'Namespace' => $metricsNamespace ,
2024-01-31 08:10:26 -07:00
]
);
2023-04-28 15:56:27 -07:00
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 " ;
2024-01-31 08:10:26 -07:00
$stats = $this -> cloudWatchClient -> getMetricStatistics (
[
2023-04-28 15:56:27 -07:00
'Dimensions' => $metricsDimensions ,
'EndTime' => time (),
'StartTime' => time () - ( 5 * 60 ),
'MetricName' => $metric [ 'MetricName' ],
'Namespace' => $metricsNamespace ,
'Period' => 60 ,
'Statistics' => [ 'Sum' ],
2024-01-31 08:10:26 -07:00
]
);
2023-04-28 15:56:27 -07:00
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.
*/
2024-01-31 08:10:26 -07:00
$this -> ec2Client -> deleteLaunchTemplate (
[
2023-04-28 15:56:27 -07:00
'LaunchTemplateName' => $this -> templateName ,
2024-01-31 08:10:26 -07:00
]
);
2023-04-28 15:56:27 -07:00
}
2024-01-31 08:10:26 -07:00
// snippet-start:[php.example_code.auto-scaling.basics.helloService]
2023-04-28 15:56:27 -07:00
public function helloService ()
{
$autoScalingClient = new AutoScalingClient ([
'region' => 'us-west-2' ,
'version' => 'latest' ,
'profile' => 'default' ,
]);
$groups = $autoScalingClient -> describeAutoScalingGroups ([]);
var_dump ( $groups );
}
2024-01-31 08:10:26 -07:00
// snippet-end:[php.example_code.auto-scaling.basics.helloService]
2023-04-28 15:56:27 -07:00
}
2024-01-31 08:10:26 -07:00
// snippet-end:[php.example_code.auto-scaling.basics.scenario]
