Java AmazonAutoScaling类代码示例

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
/***
 * Get list of {@link AutoScalingGroup}s for a given tag
 *
 * @param tag Tag to filter the auto scaling groups
 * @return List of {@link AutoScalingGroup}s qualifying the filter tag
 */
public List<AutoScalingGroup> getAutoScalingGroupsWithTag(Tag tag) {

  final AmazonAutoScaling autoScaling = getAmazonAutoScalingClient();

  final DescribeAutoScalingGroupsRequest describeAutoScalingGroupsRequest = new DescribeAutoScalingGroupsRequest();

  final List<AutoScalingGroup> allAutoScalingGroups = autoScaling
      .describeAutoScalingGroups(describeAutoScalingGroupsRequest)
      .getAutoScalingGroups();

  final List<AutoScalingGroup> filteredAutoScalingGroups = Lists.newArrayList();
  for (AutoScalingGroup autoScalingGroup : allAutoScalingGroups) {
    for (TagDescription tagDescription : autoScalingGroup.getTags()) {
      if (tagDescription.getKey().equalsIgnoreCase(tag.getKey()) &&
          tagDescription.getValue().equalsIgnoreCase(tag.getValue())) {
        filteredAutoScalingGroups.add(autoScalingGroup);
      }
    }
  }

  return filteredAutoScalingGroups;
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
/**
 * Actual membership AWS source of truth...
 */
@Override
public int getRacMembershipSize() {
    AmazonAutoScaling client = null;

    try {
        client = getAutoScalingClient();
        DescribeAutoScalingGroupsRequest asgReq = new DescribeAutoScalingGroupsRequest().withAutoScalingGroupNames(config.getASGName());
        DescribeAutoScalingGroupsResult res = client.describeAutoScalingGroups(asgReq);

        int size = 0;
        for (AutoScalingGroup asg : res.getAutoScalingGroups()) {
            size += asg.getMaxSize();
        }

        logger.info(String.format("Query on ASG returning %d instances", size));

        return size;
    } finally {
        if (client != null) {
            client.shutdown();
        }
    }
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
@Override
public void expandRacMembership(int count) {
    AmazonAutoScaling client = null;

    try {
        client = getAutoScalingClient();
        DescribeAutoScalingGroupsRequest asgReq = new DescribeAutoScalingGroupsRequest().withAutoScalingGroupNames(config.getASGName());
        DescribeAutoScalingGroupsResult res = client.describeAutoScalingGroups(asgReq);
        AutoScalingGroup asg = res.getAutoScalingGroups().get(0);
        UpdateAutoScalingGroupRequest ureq = new UpdateAutoScalingGroupRequest();
        ureq.setAutoScalingGroupName(asg.getAutoScalingGroupName());
        ureq.setMinSize(asg.getMinSize() + 1);
        ureq.setMaxSize(asg.getMinSize() + 1);
        ureq.setDesiredCapacity(asg.getMinSize() + 1);
        client.updateAutoScalingGroup(ureq);
    } finally {
        if (client != null) {
            client.shutdown();
        }
    }
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
@Bean
public AmazonAutoScaling amazonAutoScalingClient(final AWSCredentialsProvider awsCredentialsProvider,
    final ClientConfiguration awsClientConfig, final Region awsRegion) {
    return AmazonAutoScalingClientBuilder.standard()
        .withCredentials(awsCredentialsProvider)
        .withClientConfiguration(awsClientConfig)
        .withRegion(awsRegion.getName())
        .build();
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
/**
 * Binds all the Amazon services used.
 */
@Override
protected void configure() {
    final Region region = Region.getRegion(Regions.fromName(regionName));
    bind(AmazonEC2.class).toInstance(createAmazonClientInstance(AmazonEC2Client.class, region));
    bind(AmazonCloudFormation.class).toInstance(createAmazonClientInstance(AmazonCloudFormationClient.class, region));
    bind(AmazonIdentityManagement.class).toInstance(createAmazonClientInstance(AmazonIdentityManagementClient.class, region));
    bind(AWSKMS.class).toInstance(createAmazonClientInstance(AWSKMSClient.class, region));
    bind(AmazonS3.class).toInstance(createAmazonClientInstance(AmazonS3Client.class, region));
    bind(AmazonAutoScaling.class).toInstance(createAmazonClientInstance(AmazonAutoScalingClient.class, region));
    bind(AWSSecurityTokenService.class).toInstance(createAmazonClientInstance(AWSSecurityTokenServiceClient.class, region));
    bind(AWSLambda.class).toInstance(createAmazonClientInstance(AWSLambdaClient.class, region));
    bind(AmazonSNS.class).toInstance(createAmazonClientInstance(AmazonSNSClient.class, region));
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
@Before
public void setup() {
    autoScalingClient = mock(AmazonAutoScaling.class);
    ec2Client = mock(AmazonEC2.class);

    autoScalingService = new AutoScalingService(autoScalingClient, ec2Client);
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
/***
 * Initialize the AWS SDK Client
 *
 * @param awsClusterSecurityManager The {@link AWSClusterSecurityManager} to fetch AWS credentials
 * @param region The Amazon AWS {@link Region}
 */
public AWSSdkClient(final AWSClusterSecurityManager awsClusterSecurityManager, final Region region) {
  this.amazonEC2Supplier = Suppliers.memoize(new Supplier<AmazonEC2>() {
    @Override
    public AmazonEC2 get() {
      AmazonEC2Client amazonEC2 = new AmazonEC2Client(awsClusterSecurityManager.getCredentialsProvider());
      amazonEC2.setRegion(region);
      return amazonEC2;
    }
  });
  this.amazonS3Supplier = Suppliers.memoize(new Supplier<AmazonS3>() {
    @Override
    public AmazonS3 get() {
      AmazonS3Client amazonS3 = new AmazonS3Client(awsClusterSecurityManager.getCredentialsProvider());
      amazonS3.setRegion(region);
      return amazonS3;
    }
  });
  this.amazonAutoScalingSupplier = Suppliers.memoize(new Supplier<AmazonAutoScaling>() {
    @Override
    public AmazonAutoScaling get() {
      AmazonAutoScalingClient amazonAutoScaling =
              new AmazonAutoScalingClient(awsClusterSecurityManager.getCredentialsProvider());
      amazonAutoScaling.setRegion(region);
      return amazonAutoScaling;
    }
  });
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
/***
 * Delete an auto scaling group by its name
 *
 * @param autoScalingGroupName Name of auto scaling group to delete
 * @param shouldForceDelete If the AutoScalingGroup should be deleted without waiting for instances to terminate
 */
public void deleteAutoScalingGroup(String autoScalingGroupName,
    boolean shouldForceDelete) {

  final AmazonAutoScaling autoScaling = getAmazonAutoScalingClient();

  final DeleteAutoScalingGroupRequest deleteLaunchConfigurationRequest = new DeleteAutoScalingGroupRequest()
      .withAutoScalingGroupName(autoScalingGroupName)
      .withForceDelete(shouldForceDelete);

  autoScaling.deleteAutoScalingGroup(deleteLaunchConfigurationRequest);

  LOGGER.info("Deleted AutoScalingGroup: " + autoScalingGroupName);
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
@Override
public Map<String, List<String>> getRacMembership(Collection<String> autoScalingGroupNames) {
    if (CollectionUtils.isEmpty(autoScalingGroupNames)) {
        return Collections.emptyMap();
    }

    AmazonAutoScaling client = null;

    try {
        client = getAutoScalingClient();
        DescribeAutoScalingGroupsRequest describeAutoScalingGroupsRequest =
                new DescribeAutoScalingGroupsRequest().withAutoScalingGroupNames(autoScalingGroupNames);
        DescribeAutoScalingGroupsResult describeAutoScalingGroupsResult = client.describeAutoScalingGroups(describeAutoScalingGroupsRequest);

        Map<String, List<String>> asgs = new HashMap<>();
        for (AutoScalingGroup autoScalingGroup : describeAutoScalingGroupsResult.getAutoScalingGroups()) {
            List<String> asgInstanceIds = Lists.newArrayList();
            for (Instance asgInstance : autoScalingGroup.getInstances()) {
                if (!(asgInstance.getLifecycleState().equalsIgnoreCase("terminating") ||
                        asgInstance.getLifecycleState().equalsIgnoreCase("shutting-down") ||
                        asgInstance.getLifecycleState().equalsIgnoreCase("terminated"))) {
                    asgInstanceIds.add(asgInstance.getInstanceId());
                }
            }
            asgs.put(autoScalingGroup.getAutoScalingGroupName(), asgInstanceIds);
            logger.info("AWS returned the following instance ID's for {} ASG: {}",
                    autoScalingGroup.getAutoScalingGroupName(),
                    StringUtils.join(asgInstanceIds, ","));
        }

        return asgs;
    } finally {
        if (client != null) {
            client.shutdown();
        }
    }
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
private AmazonAutoScaling findClient(Account account, Region region) {
        // TODO: need to config client config parameter. ignore it for now.
        // TODO: need a cached version based on account and region as key
        AWSCredentials credential = new BasicAWSCredentials(account.getAccessKeyId(), account.getSecretAccessKey());
        AmazonAutoScaling as = new AmazonAutoScalingClient(credential);
//        as.setEndpoint(region.toAsEndpoint());
        return as;
    }
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
@Override
public List<AbstractResource<?>> describeLaunchConfigurations(Account account, Region region, DateTime dt) {
    AmazonAutoScaling as = findClient(account, region);

    DescribeLaunchConfigurationsRequest req = new DescribeLaunchConfigurationsRequest();
    log.debug("start describing instances for account:{} in region:{} via api", account.getId() + "=>" + account.getName(), region);
    DescribeLaunchConfigurationsResult res = as.describeLaunchConfigurations(req);

    return converter.toAsLaunchConfigurations(res.getLaunchConfigurations(), account.getId(), region, dt);
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
@Override
public List<AbstractResource<?>> describeAutoScalingGroups(Account account, Region region, DateTime dt) {
    AmazonAutoScaling as = findClient(account, region);

    DescribeAutoScalingGroupsRequest req = new DescribeAutoScalingGroupsRequest();
    log.debug("start describing auto scaling groups for account:{} in region:{} via api", account.getId() + "=>" + account.getName(), region);
    DescribeAutoScalingGroupsResult res = as.describeAutoScalingGroups(req);

    return converter.toAsGroups(res.getAutoScalingGroups(), account.getId(), region, dt);
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
@Inject
public AutoScalingService(final AmazonAutoScaling autoScalingClient, final AmazonEC2 ec2Client) {
    this.autoScalingClient = autoScalingClient;
    this.ec2Client = ec2Client;
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
@Bean
public AmazonAutoScaling autoScaling() {
    AmazonAutoScaling client = new AmazonAutoScalingClient();
    client.setRegion(region);
    return client;
}
 

import com.amazonaws.services.autoscaling.AmazonAutoScaling; //导入依赖的package包/类
public static void main( String[] args ) throws IOException {
 final String env = "prod";
   AWSCredentials credentials =
   	      new PropertiesCredentials(
   	          ShutdownWorkers.class.getResourceAsStream( "/AwsCredentials.properties" )
   	    );
  
    try {          
  	  // Scalo a zero
  	  int min = 0;
  	  int desired = 0;
        int max = 0;
        
  	  AmazonAutoScaling as = new AmazonAutoScalingClient(credentials);
  	  as.setEndpoint("autoscaling.eu-west-1.amazonaws.com");
        DescribeAutoScalingGroupsResult dasgres = as.describeAutoScalingGroups();
        List<AutoScalingGroup> lasg = dasgres.getAutoScalingGroups();
        for (AutoScalingGroup asg : lasg) {
	if(asg.getAutoScalingGroupName().equals("asg-kopjra-prod-workers")){
		desired = asg.getDesiredCapacity();
		max = asg.getMaxSize();
		min = asg.getMinSize();
		break;
	}
        }
        
        UpdateAutoScalingGroupRequest uasgr = new UpdateAutoScalingGroupRequest();
        uasgr.setAutoScalingGroupName("asg-kopjra-prod-workers");
        uasgr.setDesiredCapacity(0);
        uasgr.setMaxSize(0);
        uasgr.setMinSize(0);
        as.updateAutoScalingGroup(uasgr);
        
        System.out.println("Done: workers shutting down!");
        System.out.println("When you run the StartupWorkers, remember to use the following parameters: "+min+" "+max+" "+desired);
        
    } catch (AmazonServiceException ase) {
        System.err.println( "AmazonServiceException" );
    } catch (AmazonClientException ace) {
        System.err.println( "AmazonClientException" );
    } catch (Exception e){
  	  System.err.println( "OtherException" );
    }
}