func ExampleCloudFormation_CreateStack() { svc := cloudformation.New(session.New()) params := &cloudformation.CreateStackInput{ StackName: aws.String("StackName"), // Required Capabilities: []*string{ aws.String("Capability"), // Required // More values... }, DisableRollback: aws.Bool(true), NotificationARNs: []*string{ aws.String("NotificationARN"), // Required // More values... }, OnFailure: aws.String("OnFailure"), Parameters: []*cloudformation.Parameter{ { // Required ParameterKey: aws.String("ParameterKey"), ParameterValue: aws.String("ParameterValue"), UsePreviousValue: aws.Bool(true), }, // More values... }, ResourceTypes: []*string{ aws.String("ResourceType"), // Required // More values... }, StackPolicyBody: aws.String("StackPolicyBody"), StackPolicyURL: aws.String("StackPolicyURL"), Tags: []*cloudformation.Tag{ { // Required Key: aws.String("TagKey"), Value: aws.String("TagValue"), }, // More values... }, TemplateBody: aws.String("TemplateBody"), TemplateURL: aws.String("TemplateURL"), TimeoutInMinutes: aws.Int64(1), } resp, err := svc.CreateStack(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleAutoScaling_CreateAutoScalingGroup() { svc := autoscaling.New(session.New()) params := &autoscaling.CreateAutoScalingGroupInput{ AutoScalingGroupName: aws.String("XmlStringMaxLen255"), // Required MaxSize: aws.Int64(1), // Required MinSize: aws.Int64(1), // Required AvailabilityZones: []*string{ aws.String("XmlStringMaxLen255"), // Required // More values... }, DefaultCooldown: aws.Int64(1), DesiredCapacity: aws.Int64(1), HealthCheckGracePeriod: aws.Int64(1), HealthCheckType: aws.String("XmlStringMaxLen32"), InstanceId: aws.String("XmlStringMaxLen19"), LaunchConfigurationName: aws.String("ResourceName"), LoadBalancerNames: []*string{ aws.String("XmlStringMaxLen255"), // Required // More values... }, NewInstancesProtectedFromScaleIn: aws.Bool(true), PlacementGroup: aws.String("XmlStringMaxLen255"), Tags: []*autoscaling.Tag{ { // Required Key: aws.String("TagKey"), // Required PropagateAtLaunch: aws.Bool(true), ResourceId: aws.String("XmlString"), ResourceType: aws.String("XmlString"), Value: aws.String("TagValue"), }, // More values... }, TerminationPolicies: []*string{ aws.String("XmlStringMaxLen1600"), // Required // More values... }, VPCZoneIdentifier: aws.String("XmlStringMaxLen255"), } resp, err := svc.CreateAutoScalingGroup(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func GetRelease(app, id string) (*Release, error) { if id == "" { return nil, fmt.Errorf("no release id") } req := &dynamodb.GetItemInput{ ConsistentRead: aws.Bool(true), Key: map[string]*dynamodb.AttributeValue{ "id": &dynamodb.AttributeValue{S: aws.String(id)}, }, TableName: aws.String(releasesTable(app)), } res, err := DynamoDB().GetItem(req) if err != nil { return nil, err } if res.Item == nil { return nil, fmt.Errorf("no such release: %s", id) } release := releaseFromItem(res.Item) return release, nil }
func ExampleS3_DeleteObjects() { svc := s3.New(session.New()) params := &s3.DeleteObjectsInput{ Bucket: aws.String("BucketName"), // Required Delete: &s3.Delete{ // Required Objects: []*s3.ObjectIdentifier{ // Required { // Required Key: aws.String("ObjectKey"), // Required VersionId: aws.String("ObjectVersionId"), }, // More values... }, Quiet: aws.Bool(true), }, MFA: aws.String("MFA"), RequestPayer: aws.String("RequestPayer"), } resp, err := svc.DeleteObjects(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ListReleases(app string) (Releases, error) { req := &dynamodb.QueryInput{ KeyConditions: map[string]*dynamodb.Condition{ "app": &dynamodb.Condition{ AttributeValueList: []*dynamodb.AttributeValue{ &dynamodb.AttributeValue{S: aws.String(app)}, }, ComparisonOperator: aws.String("EQ"), }, }, IndexName: aws.String("app.created"), Limit: aws.Int64(20), ScanIndexForward: aws.Bool(false), TableName: aws.String(releasesTable(app)), } res, err := DynamoDB().Query(req) if err != nil { return nil, err } releases := make(Releases, len(res.Items)) for i, item := range res.Items { releases[i] = *releaseFromItem(item) } return releases, nil }
func ExampleLambda_CreateFunction() { svc := lambda.New(session.New()) params := &lambda.CreateFunctionInput{ Code: &lambda.FunctionCode{ // Required S3Bucket: aws.String("S3Bucket"), S3Key: aws.String("S3Key"), S3ObjectVersion: aws.String("S3ObjectVersion"), ZipFile: []byte("PAYLOAD"), }, FunctionName: aws.String("FunctionName"), // Required Handler: aws.String("Handler"), // Required Role: aws.String("RoleArn"), // Required Runtime: aws.String("Runtime"), // Required Description: aws.String("Description"), MemorySize: aws.Int64(1), Publish: aws.Bool(true), Timeout: aws.Int64(1), } resp, err := svc.CreateFunction(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleCloudFormation_EstimateTemplateCost() { svc := cloudformation.New(session.New()) params := &cloudformation.EstimateTemplateCostInput{ Parameters: []*cloudformation.Parameter{ { // Required ParameterKey: aws.String("ParameterKey"), ParameterValue: aws.String("ParameterValue"), UsePreviousValue: aws.Bool(true), }, // More values... }, TemplateBody: aws.String("TemplateBody"), TemplateURL: aws.String("TemplateURL"), } resp, err := svc.EstimateTemplateCost(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleCloudWatchLogs_FilterLogEvents() { svc := cloudwatchlogs.New(session.New()) params := &cloudwatchlogs.FilterLogEventsInput{ LogGroupName: aws.String("LogGroupName"), // Required EndTime: aws.Int64(1), FilterPattern: aws.String("FilterPattern"), Interleaved: aws.Bool(true), Limit: aws.Int64(1), LogStreamNames: []*string{ aws.String("LogStreamName"), // Required // More values... }, NextToken: aws.String("NextToken"), StartTime: aws.Int64(1), } resp, err := svc.FilterLogEvents(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
// Shortcut for updating current parameters // If template changed, more care about new or removed parameters must be taken (see Release.Promote or System.Save) func (a *App) UpdateParams(changes map[string]string) error { req := &cloudformation.UpdateStackInput{ StackName: aws.String(a.StackName()), Capabilities: []*string{aws.String("CAPABILITY_IAM")}, UsePreviousTemplate: aws.Bool(true), } params := a.Parameters for key, val := range changes { params[key] = val } // sort parameters by key name to make test requests stable var keys []string for k, _ := range params { keys = append(keys, k) } sort.Strings(keys) for _, key := range keys { val := params[key] req.Parameters = append(req.Parameters, &cloudformation.Parameter{ ParameterKey: aws.String(key), ParameterValue: aws.String(val), }) } _, err := UpdateStack(req) return err }
func ExampleAutoScaling_DeleteTags() { svc := autoscaling.New(session.New()) params := &autoscaling.DeleteTagsInput{ Tags: []*autoscaling.Tag{ // Required { // Required Key: aws.String("TagKey"), // Required PropagateAtLaunch: aws.Bool(true), ResourceId: aws.String("XmlString"), ResourceType: aws.String("XmlString"), Value: aws.String("TagValue"), }, // More values... }, } resp, err := svc.DeleteTags(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func (a *App) UpdateParamsAndTemplate(changes map[string]string, template string) error { req := &cloudformation.UpdateStackInput{ StackName: aws.String(a.Name), Capabilities: []*string{aws.String("CAPABILITY_IAM")}, } if template != "" { req.TemplateURL = aws.String(template) } else { req.UsePreviousTemplate = aws.Bool(true) } params := a.Parameters for key, val := range changes { params[key] = val } for key, val := range params { req.Parameters = append(req.Parameters, &cloudformation.Parameter{ ParameterKey: aws.String(key), ParameterValue: aws.String(val), }) } _, err := UpdateStack(req) return err }
func StartCluster() { var log = logger.New("ns=cluster_monitor") defer recoverWith(func(err error) { helpers.Error(log, err) }) for _ = range time.Tick(5 * time.Minute) { log.Log("tick") instances := Instances{} err := instances.describeASG() if err != nil { log.Error(err) continue } err = instances.describeECS() if err != nil { log.Error(err) continue } // TODO: Add an instances.testDocker() call to the mission critical path // Test if ASG Instance is registered and connected in ECS cluster for _, i := range instances { if !i.ASG { // TODO: Rogue instance?! Terminate? continue } if !i.ECS { // Not registered or not connected => set Unhealthy _, err := models.AutoScaling().SetInstanceHealth( &autoscaling.SetInstanceHealthInput{ HealthStatus: aws.String("Unhealthy"), InstanceId: aws.String(i.Id), ShouldRespectGracePeriod: aws.Bool(true), }, ) i.Unhealthy = true if err != nil { log.Error(err) continue } } } log.Log(instances.log()) } }
// Use S3 for simplicity func TestPaginationTruncation(t *testing.T) { client := s3.New(unit.Session) reqNum := 0 resps := []*s3.ListObjectsOutput{ {IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key1")}}}, {IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key2")}}}, {IsTruncated: aws.Bool(false), Contents: []*s3.Object{{Key: aws.String("Key3")}}}, {IsTruncated: aws.Bool(true), Contents: []*s3.Object{{Key: aws.String("Key4")}}}, } client.Handlers.Send.Clear() // mock sending client.Handlers.Unmarshal.Clear() client.Handlers.UnmarshalMeta.Clear() client.Handlers.ValidateResponse.Clear() client.Handlers.Unmarshal.PushBack(func(r *request.Request) { r.Data = resps[reqNum] reqNum++ }) params := &s3.ListObjectsInput{Bucket: aws.String("bucket")} results := []string{} err := client.ListObjectsPages(params, func(p *s3.ListObjectsOutput, last bool) bool { results = append(results, *p.Contents[0].Key) return true }) assert.Equal(t, []string{"Key1", "Key2", "Key3"}, results) assert.Nil(t, err) // Try again without truncation token at all reqNum = 0 resps[1].IsTruncated = nil resps[2].IsTruncated = aws.Bool(true) results = []string{} err = client.ListObjectsPages(params, func(p *s3.ListObjectsOutput, last bool) bool { results = append(results, *p.Contents[0].Key) return true }) assert.Equal(t, []string{"Key1", "Key2"}, results) assert.Nil(t, err) }
func BenchmarkEC2QueryBuild_Simple_ec2AttachNetworkInterface(b *testing.B) { params := &ec2.AttachNetworkInterfaceInput{ DeviceIndex: aws.Int64(1), // Required InstanceId: aws.String("String"), // Required NetworkInterfaceId: aws.String("String"), // Required DryRun: aws.Bool(true), } benchEC2QueryBuild(b, "AttachNetworkInterface", params) }
func ExampleELB_ModifyLoadBalancerAttributes() { svc := elb.New(session.New()) params := &elb.ModifyLoadBalancerAttributesInput{ LoadBalancerAttributes: &elb.LoadBalancerAttributes{ // Required AccessLog: &elb.AccessLog{ Enabled: aws.Bool(true), // Required EmitInterval: aws.Int64(1), S3BucketName: aws.String("S3BucketName"), S3BucketPrefix: aws.String("AccessLogPrefix"), }, AdditionalAttributes: []*elb.AdditionalAttribute{ { // Required Key: aws.String("StringVal"), Value: aws.String("StringVal"), }, // More values... }, ConnectionDraining: &elb.ConnectionDraining{ Enabled: aws.Bool(true), // Required Timeout: aws.Int64(1), }, ConnectionSettings: &elb.ConnectionSettings{ IdleTimeout: aws.Int64(1), // Required }, CrossZoneLoadBalancing: &elb.CrossZoneLoadBalancing{ Enabled: aws.Bool(true), // Required }, }, LoadBalancerName: aws.String("AccessPointName"), // Required } resp, err := svc.ModifyLoadBalancerAttributes(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func TestMultipleHandlers(t *testing.T) { r := &request.Request{} l := request.HandlerList{} l.PushBack(func(r *request.Request) { r.Data = nil }) l.PushFront(func(r *request.Request) { r.Data = aws.Bool(true) }) l.Run(r) if r.Data != nil { t.Error("Expected handler to execute") } }
func TestSendMessageChecksumInvalidNoValidation(t *testing.T) { s := sqs.New(unit.Session, &aws.Config{ DisableParamValidation: aws.Bool(true), DisableComputeChecksums: aws.Bool(true), }) s.Handlers.Send.Clear() req, _ := s.SendMessageRequest(&sqs.SendMessageInput{ MessageBody: aws.String("test"), }) req.Handlers.Send.PushBack(func(r *request.Request) { body := ioutil.NopCloser(bytes.NewReader([]byte(""))) r.HTTPResponse = &http.Response{StatusCode: 200, Body: body} r.Data = &sqs.SendMessageOutput{ MD5OfMessageBody: aws.String("000"), MessageId: aws.String("12345"), } }) err := req.Send() assert.NoError(t, err) }
func ExampleAutoScaling_CreateLaunchConfiguration() { svc := autoscaling.New(session.New()) params := &autoscaling.CreateLaunchConfigurationInput{ LaunchConfigurationName: aws.String("XmlStringMaxLen255"), // Required AssociatePublicIpAddress: aws.Bool(true), BlockDeviceMappings: []*autoscaling.BlockDeviceMapping{ { // Required DeviceName: aws.String("XmlStringMaxLen255"), // Required Ebs: &autoscaling.Ebs{ DeleteOnTermination: aws.Bool(true), Encrypted: aws.Bool(true), Iops: aws.Int64(1), SnapshotId: aws.String("XmlStringMaxLen255"), VolumeSize: aws.Int64(1), VolumeType: aws.String("BlockDeviceEbsVolumeType"), }, NoDevice: aws.Bool(true), VirtualName: aws.String("XmlStringMaxLen255"), }, // More values... }, ClassicLinkVPCId: aws.String("XmlStringMaxLen255"), ClassicLinkVPCSecurityGroups: []*string{ aws.String("XmlStringMaxLen255"), // Required // More values... }, EbsOptimized: aws.Bool(true), IamInstanceProfile: aws.String("XmlStringMaxLen1600"), ImageId: aws.String("XmlStringMaxLen255"), InstanceId: aws.String("XmlStringMaxLen19"), InstanceMonitoring: &autoscaling.InstanceMonitoring{ Enabled: aws.Bool(true), }, InstanceType: aws.String("XmlStringMaxLen255"), KernelId: aws.String("XmlStringMaxLen255"), KeyName: aws.String("XmlStringMaxLen255"), PlacementTenancy: aws.String("XmlStringMaxLen64"), RamdiskId: aws.String("XmlStringMaxLen255"), SecurityGroups: []*string{ aws.String("XmlString"), // Required // More values... }, SpotPrice: aws.String("SpotPrice"), UserData: aws.String("XmlStringUserData"), } resp, err := svc.CreateLaunchConfiguration(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func TestCopySourceSSECustomerKeyOverHTTPError(t *testing.T) { s := s3.New(unit.Session, &aws.Config{DisableSSL: aws.Bool(true)}) req, _ := s.CopyObjectRequest(&s3.CopyObjectInput{ Bucket: aws.String("bucket"), CopySource: aws.String("bucket/source"), Key: aws.String("dest"), CopySourceSSECustomerKey: aws.String("key"), }) err := req.Build() assert.Error(t, err) assert.Equal(t, "ConfigError", err.(awserr.Error).Code()) assert.Contains(t, err.(awserr.Error).Message(), "cannot send SSE keys over HTTP") }
func TestNoErrors(t *testing.T) { input := &StructShape{ RequiredList: []*ConditionalStructShape{}, RequiredMap: map[string]*ConditionalStructShape{ "key1": {Name: aws.String("Name")}, "key2": {Name: aws.String("Name")}, }, RequiredBool: aws.Bool(true), OptionalStruct: &ConditionalStructShape{Name: aws.String("Name")}, } req := testSvc.NewRequest(&request.Operation{}, input, nil) corehandlers.ValidateParametersHandler.Fn(req) require.NoError(t, req.Error) }
func TestValidateCRC32DoesNotMatchNoComputeChecksum(t *testing.T) { svc := dynamodb.New(unit.Session, &aws.Config{ MaxRetries: aws.Int(2), DisableComputeChecksums: aws.Bool(true), }) svc.Handlers.Send.Clear() // mock sending req := mockCRCResponse(svc, 200, `{"TableNames":["A"]}`, "1234") assert.NoError(t, req.Error) assert.Equal(t, 0, int(req.RetryCount)) // CRC check disabled. Does not affect output parsing out := req.Data.(*dynamodb.ListTablesOutput) assert.Equal(t, "A", *out.TableNames[0]) }
func ExampleCloudWatch_PutMetricAlarm() { svc := cloudwatch.New(session.New()) params := &cloudwatch.PutMetricAlarmInput{ AlarmName: aws.String("AlarmName"), // Required ComparisonOperator: aws.String("ComparisonOperator"), // Required EvaluationPeriods: aws.Int64(1), // Required MetricName: aws.String("MetricName"), // Required Namespace: aws.String("Namespace"), // Required Period: aws.Int64(1), // Required Statistic: aws.String("Statistic"), // Required Threshold: aws.Float64(1.0), // Required ActionsEnabled: aws.Bool(true), AlarmActions: []*string{ aws.String("ResourceName"), // Required // More values... }, AlarmDescription: aws.String("AlarmDescription"), Dimensions: []*cloudwatch.Dimension{ { // Required Name: aws.String("DimensionName"), // Required Value: aws.String("DimensionValue"), // Required }, // More values... }, InsufficientDataActions: []*string{ aws.String("ResourceName"), // Required // More values... }, OKActions: []*string{ aws.String("ResourceName"), // Required // More values... }, Unit: aws.String("StandardUnit"), } resp, err := svc.PutMetricAlarm(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func TestMetadataNotAvailable(t *testing.T) { c := ec2metadata.New(session.New()) c.Handlers.Send.Clear() c.Handlers.Send.PushBack(func(r *request.Request) { r.HTTPResponse = &http.Response{ StatusCode: int(0), Status: http.StatusText(int(0)), Body: ioutil.NopCloser(bytes.NewReader([]byte{})), } r.Error = awserr.New("RequestError", "send request failed", nil) r.Retryable = aws.Bool(true) // network errors are retryable }) available := c.Available() assert.False(t, available) }
func TestNestedMissingRequiredParameters(t *testing.T) { input := &StructShape{ RequiredList: []*ConditionalStructShape{{}}, RequiredMap: map[string]*ConditionalStructShape{ "key1": {Name: aws.String("Name")}, "key2": {}, }, RequiredBool: aws.Bool(true), OptionalStruct: &ConditionalStructShape{}, } req := testSvc.NewRequest(&request.Operation{}, input, nil) corehandlers.ValidateParametersHandler.Fn(req) require.Error(t, req.Error) assert.Equal(t, "InvalidParameter", req.Error.(awserr.Error).Code()) assert.Equal(t, "3 validation errors:\n- missing required parameter: RequiredList[0].Name\n- missing required parameter: RequiredMap[\"key2\"].Name\n- missing required parameter: OptionalStruct.Name", req.Error.(awserr.Error).Message()) }
func ExampleAutoScaling_TerminateInstanceInAutoScalingGroup() { svc := autoscaling.New(session.New()) params := &autoscaling.TerminateInstanceInAutoScalingGroupInput{ InstanceId: aws.String("XmlStringMaxLen19"), // Required ShouldDecrementDesiredCapacity: aws.Bool(true), // Required } resp, err := svc.TerminateInstanceInAutoScalingGroup(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleAutoScaling_DeleteAutoScalingGroup() { svc := autoscaling.New(session.New()) params := &autoscaling.DeleteAutoScalingGroupInput{ AutoScalingGroupName: aws.String("ResourceName"), // Required ForceDelete: aws.Bool(true), } resp, err := svc.DeleteAutoScalingGroup(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
/* App logs are written to many streams, one per container Periodically describe the streams for a group For new or updating streams launch a goroutine to get and output the events */ func subscribeCloudWatchLogs(group string, output chan []byte, quit chan bool) { fmt.Printf("subscribeCloudWatchLogs group=%s\n", group) horizonTime := time.Now().Add(-2 * time.Minute) activeStreams := map[string]bool{} for { res, err := CloudWatchLogs().DescribeLogStreams(&cloudwatchlogs.DescribeLogStreamsInput{ LogGroupName: aws.String(group), OrderBy: aws.String(cloudwatchlogs.OrderByLastEventTime), Descending: aws.Bool(true), }) if err != nil { fmt.Printf("ERROR: %+v\n", err) return } for _, s := range res.LogStreams { if activeStreams[*s.LogStreamName] { continue } if s.LastEventTimestamp == nil { continue } sec := *s.LastEventTimestamp / 1000 // convert ms since epoch to sec nsec := (*s.LastEventTimestamp - (sec * 1000)) * 1000 // convert remainder to nsec lastEventTime := time.Unix(sec, nsec) // fmt.Printf("subscribeCloudWatchLogs horizonTime=%+v lastEventTime=%+v lastEventTimestamp=%d sec=%+v nsec=%+v\n", horizonTime, lastEventTime, *s.LastEventTimestamp, sec, nsec) if lastEventTime.After(horizonTime) { activeStreams[*s.LogStreamName] = true go subscribeCloudWatchLogsStream(group, *s.LogStreamName, horizonTime, output, quit) } } time.Sleep(1000 * time.Millisecond) } }
func BenchmarkEC2QueryBuild_Complex_ec2AuthorizeSecurityGroupEgress(b *testing.B) { params := &ec2.AuthorizeSecurityGroupEgressInput{ GroupId: aws.String("String"), // Required CidrIp: aws.String("String"), DryRun: aws.Bool(true), FromPort: aws.Int64(1), IpPermissions: []*ec2.IpPermission{ { // Required FromPort: aws.Int64(1), IpProtocol: aws.String("String"), IpRanges: []*ec2.IpRange{ { // Required CidrIp: aws.String("String"), }, // More values... }, PrefixListIds: []*ec2.PrefixListId{ { // Required PrefixListId: aws.String("String"), }, // More values... }, ToPort: aws.Int64(1), UserIdGroupPairs: []*ec2.UserIdGroupPair{ { // Required GroupId: aws.String("String"), GroupName: aws.String("String"), UserId: aws.String("String"), }, // More values... }, }, // More values... }, IpProtocol: aws.String("String"), SourceSecurityGroupName: aws.String("String"), SourceSecurityGroupOwnerId: aws.String("String"), ToPort: aws.Int64(1), } benchEC2QueryBuild(b, "AuthorizeSecurityGroupEgress", params) }
func ExampleECS_DeregisterContainerInstance() { svc := ecs.New(session.New()) params := &ecs.DeregisterContainerInstanceInput{ ContainerInstance: aws.String("String"), // Required Cluster: aws.String("String"), Force: aws.Bool(true), } resp, err := svc.DeregisterContainerInstance(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }
func ExampleECR_DeleteRepository() { svc := ecr.New(session.New()) params := &ecr.DeleteRepositoryInput{ RepositoryName: aws.String("RepositoryName"), // Required Force: aws.Bool(true), RegistryId: aws.String("RegistryId"), } resp, err := svc.DeleteRepository(params) if err != nil { // Print the error, cast err to awserr.Error to get the Code and // Message from an error. fmt.Println(err.Error()) return } // Pretty-print the response data. fmt.Println(resp) }