Golang EC2.CreateTags方法代码示例

// setTags is a helper to set the tags for a resource. It expects the
// tags field to be named "tags"
func setTags(conn *ec2.EC2, d *schema.ResourceData) error {
	if d.HasChange("tags") {
		oraw, nraw := d.GetChange("tags")
		o := oraw.(map[string]interface{})
		n := nraw.(map[string]interface{})
		create, remove := diffTags(tagsFromMap(o), tagsFromMap(n))

		// Set tags
		if len(remove) > 0 {
			log.Printf("[DEBUG] Removing tags: %#v from %s", remove, d.Id())
			_, err := conn.DeleteTags(&ec2.DeleteTagsInput{
				Resources: []*string{aws.String(d.Id())},
				Tags:      remove,
			})
			if err != nil {
				return err
			}
		}
		if len(create) > 0 {
			log.Printf("[DEBUG] Creating tags: %s for %s", awsutil.StringValue(create), d.Id())
			_, err := conn.CreateTags(&ec2.CreateTagsInput{
				Resources: []*string{aws.String(d.Id())},
				Tags:      create,
			})
			if err != nil {
				return err
			}
		}
	}

	return nil
}

// TagVolumesForInstance tags the volumes attached to a given instance with a
// specified string and the device name
func TagVolumesForInstance(c *ec2.EC2, i *ec2.Instance, n *string) error {
	for _, m := range i.BlockDeviceMappings {
		dn := m.DeviceName
		e := m.Ebs.VolumeId
		fmt.Printf("Tag volume %s:  %s - %s\n", *e, *n, *dn)

		p := &ec2.CreateTagsInput{
			Resources: []*string{
				aws.String(*e),
			},
			Tags: []*ec2.Tag{
				{
					Key:   aws.String("Name"),
					Value: aws.String(fmt.Sprintf("%s - %s", *n, *dn)),
				},
			},
			DryRun: aws.Bool(*DryRun),
		}

		resp, err := c.CreateTags(p)
		if err != nil {
			// Don't return because apparently when `DryRun` is set to true,
			// the API object also comes with an error.
			fmt.Println(err)
		}
		fmt.Println(resp)
	}

	return nil
}

func addDockerTagToResource(ec2Client *ec2.EC2, resource string, tagValue string, nameValue string) (taggedResource string, err error) {

	tags := []*ec2.Tag{}
	tags = append(tags, createTag(dockerEnvTag, tagValue))
	tags = append(tags, createTag(nameTag, nameValue))
	resourceArray := []*string{}
	resourceArray = append(resourceArray, &resource)

	tagCreateOutput, callErr := ec2Client.CreateTags(&ec2.CreateTagsInput{
		Resources: resourceArray,
		Tags:      tags,
	})

	if err != nil {
		err = callErr
		log.WithFields(log.Fields{
			"AWS Error": err.Error(),
			"Resource":  resource,
		}).Error("Error adding tags to VPC")
		taggedResource = ""
	} else {
		taggedResource = resource
	}

	log.WithFields(log.Fields{
		"Tags created": tagCreateOutput.SDKShapeTraits,
	}).Debug("Tags created")

	return taggedResource, err

}

func updateTags(ctx context.Context, svc ec2.EC2, resourceIds []*string) {
	if len(ctx.Tags) <= 0 {
		return
	}

	_, err := svc.CreateTags(&ec2.CreateTagsInput{
		Resources: resourceIds,
		Tags:      tagArgsToEc2Tags(ctx.Tags),
	})

	kingpin.FatalIfError(err, "Could not update tags for EC2 resources %s", resourceIds)
}

// setTags is a helper to set the tags for a resource. It expects the
// tags field to be named "tags"
func setTags(conn *ec2.EC2, d *schema.ResourceData) error {
	if d.HasChange("tags") {
		oraw, nraw := d.GetChange("tags")
		o := oraw.(map[string]interface{})
		n := nraw.(map[string]interface{})
		create, remove := diffTags(tagsFromMap(o), tagsFromMap(n))

		// Set tags
		if len(remove) > 0 {
			err := resource.Retry(2*time.Minute, func() *resource.RetryError {
				log.Printf("[DEBUG] Removing tags: %#v from %s", remove, d.Id())
				_, err := conn.DeleteTags(&ec2.DeleteTagsInput{
					Resources: []*string{aws.String(d.Id())},
					Tags:      remove,
				})
				if err != nil {
					ec2err, ok := err.(awserr.Error)
					if ok && strings.Contains(ec2err.Code(), ".NotFound") {
						return resource.RetryableError(err) // retry
					}
					return resource.NonRetryableError(err)
				}
				return nil
			})
			if err != nil {
				return err
			}
		}
		if len(create) > 0 {
			err := resource.Retry(2*time.Minute, func() *resource.RetryError {
				log.Printf("[DEBUG] Creating tags: %s for %s", create, d.Id())
				_, err := conn.CreateTags(&ec2.CreateTagsInput{
					Resources: []*string{aws.String(d.Id())},
					Tags:      create,
				})
				if err != nil {
					ec2err, ok := err.(awserr.Error)
					if ok && strings.Contains(ec2err.Code(), ".NotFound") {
						return resource.RetryableError(err) // retry
					}
					return resource.NonRetryableError(err)
				}
				return nil
			})
			if err != nil {
				return err
			}
		}
	}

	return nil
}

func CreateSnapshotTags(svc *ec2.EC2, resourceID, volumeName, volumeID string) error {
	var nKey, nVal string

	var tags []*ec2.Tag

	nKey = "Name"

	if volumeName == "" {
		nVal = fmt.Sprintf("%s: %s, %s", *tagPrefix, volumeID, time.Now().Format("2006-01-02"))
	} else {
		nVal = fmt.Sprintf("%s: %s, %s", *tagPrefix, volumeName, time.Now().Format("2006-01-02"))
	}
	tags = append(tags, &ec2.Tag{Key: &nKey, Value: &nVal})

	if *purgeAfterDays > 0 {
		var paKey, paVal string
		var pKey, pVal string
		paKey = PurgeAfterKey
		paVal = time.Now().Add(time.Duration(*purgeAfterDays*24) * time.Hour).Format(PurgeAfterFormat)
		tags = append(tags, &ec2.Tag{Key: &paKey, Value: &paVal})

		pKey = PurgeAllowKey
		pVal = "true"
		tags = append(tags, &ec2.Tag{Key: &pKey, Value: &pVal})
	}

	cti := ec2.CreateTagsInput{Tags: tags}
	cti.Resources = append(cti.Resources, &resourceID)

	_, err := svc.CreateTags(&cti)
	if err != nil {
		return err
	}

	return nil
}

func createInstance(svc *ec2.EC2, config *Config, ec2config EC2, userdata string, doneChan chan string) int {
	var min int64
	var max int64
	min = 1
	max = 1

	remainingSteps := 0

	var subnet string
	if ec2config.HasExternalIP {
		subnet = config.PublicSubnetId
	} else {
		subnet = config.PrivateSubnetId
	}

	//fmt.Println("Public: ", config.PublicSubnetId)
	//fmt.Println("Private: ", config.PrivateSubnetId)
	//fmt.Println("Using: ", subnet)
	//if isEc2PartofLb(config, ec2config) {
	//	subnet = config.PrivateSubnetId
	//}

	ec2config.SecurityGroupIds = getSecurityGroupIds(svc, config, ec2config.SecurityGroups)
	keyname := ec2config.KeyName
	if keyname == "" {
		keyname = config.KeyPair
	}
	params := &ec2.RunInstancesInput{
		ImageId:          &ec2config.AMI,
		InstanceType:     &ec2config.InstanceType,
		MaxCount:         &max,
		MinCount:         &min,
		KeyName:          &keyname,
		UserData:         &userdata,
		SubnetId:         &subnet,
		SecurityGroupIds: ec2config.SecurityGroupIds,
	}
	//fmt.Println("Create instance params:", params)

	rres, err := svc.RunInstances(params)
	if err != nil {
		fmt.Println("Failed to create instance", err)
		fmt.Println(rres)
	} else {
		fmt.Printf("Created instance %s: %s\n", ec2config.Name, *rres.Instances[0].InstanceId)
		ec2config.InstanceId = *rres.Instances[0].InstanceId
		//fmt.Println(rres)

		//fmt.Println("Sleeping for a sec to give AWS some time ...")

		time.Sleep(1 * time.Second)

		keyname := "Name"
		_, err := svc.CreateTags(&ec2.CreateTagsInput{
			Resources: []*string{rres.Instances[0].InstanceId},
			Tags: []*ec2.Tag{
				&ec2.Tag{
					Key:   &keyname,
					Value: &ec2config.Name,
				},
			},
		})
		//fmt.Println(tres)

		if err != nil {
			fmt.Println("Could not create tags for instance ", rres.Instances[0].InstanceId)
			fmt.Println(err)
		} //else {
		//fmt.Println("Created tag Name with value", ec2config.Name)
		//fmt.Println("isnat", ec2config.IsNat)
		if ec2config.IsNat {
			remainingSteps++

			go func() {

				err = waitForNonPendingState(svc, rres.Instances[0].InstanceId)
				if err != nil {
					fmt.Println(err)
					doneChan <- "Gave up waiting on ec2 to leave pending state."
					return
				}

				bv := false
				abv := &ec2.AttributeBooleanValue{Value: &bv}
				miai := &ec2.ModifyInstanceAttributeInput{InstanceId: rres.Instances[0].InstanceId, SourceDestCheck: abv}
				_, err := svc.ModifyInstanceAttribute(miai)
				if err != nil {
					fmt.Println("Failed to change sourcedestcheck", err)
				}

				routeid, err := getPrivateRouteTable(svc, &config.PrivateSubnetId, config.VpcId)
				if err != nil {
					routeid, err = createPrivateRouteTable(svc, config)
				} else {
					_ = deleteDefaultRoute(svc, routeid)
					/*if err != nil {
						fmt.Println("Error deleting default route or default route existed", err)
					}*/
				}

//.........这里部分代码省略.........