Esempio n. 1
0
func AssociateEIP(cli *ec2.EC2, eipAllocId, instanceId string) (*string, error) {
	params := &ec2.AssociateAddressInput{
		AllocationId:       aws.String(eipAllocId),
		AllowReassociation: aws.Bool(true),
		InstanceId:         aws.String(instanceId),
	}
	resp, err := cli.AssociateAddress(params)

	return resp.AssociationId, err
}
Esempio n. 2
0
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)
					}*/
				}

				defr := "0.0.0.0/0"
				cri := &ec2.CreateRouteInput{DestinationCidrBlock: &defr, InstanceId: rres.Instances[0].InstanceId, RouteTableId: routeid}
				_, err = svc.CreateRoute(cri)
				if err != nil {
					fmt.Println("Error adding new default route to NAT node", err)
				}
				doneChan <- fmt.Sprintf("Configured for NAT: %s", ec2config.Name)
			}()

		}
		//}

		//fmt.Println("hasexternalip ", ec2config.HasExternalIP)
		if ec2config.HasExternalIP {
			remainingSteps++

			go func() {
				vpcs := "vpc"
				aao, err := svc.AllocateAddress(&ec2.AllocateAddressInput{Domain: &vpcs})
				if err != nil {
					fmt.Println("Could not allocate addr:", err)
				}

				err = waitForNonPendingState(svc, rres.Instances[0].InstanceId)
				if err != nil {
					fmt.Println(err)
				} else {
					//aai,err := svc.AssociateAddress(&ec2.AssociateAddressInput{ PublicIp: aao.PublicIp, InstanceId: rres.Instances[0].InstanceId })
					_, err := svc.AssociateAddress(&ec2.AssociateAddressInput{AllocationId: aao.AllocationId, InstanceId: rres.Instances[0].InstanceId})
					if err != nil {
						fmt.Println("Could not assign addr:", err)
					}
				}

				//fmt.Println("External IP: ", *aao.PublicIp)
				doneChan <- fmt.Sprintf("External IP for %s assigned: %s", ec2config.Name, *aao.PublicIp)
			}()

		}

	}

	return remainingSteps

}