Golang EC2.CreateRoute方法代碼示例

func addRoute(ec2Client *ec2.EC2, route *providers.Route, routeTableID string, gatewayID string) (success bool, warnings []string, err []error) {

	//Create Route
	createRouteOutput, rtErr := ec2Client.CreateRoute(&ec2.CreateRouteInput{
		RouteTableID:         &routeTableID,
		DestinationCIDRBlock: &route.CidrBlock,
		GatewayID:            &gatewayID,
	})
	if rtErr != nil {
		log.WithFields(log.Fields{
			"AWS Error":    rtErr.Error(),
			"RouteTableID": &routeTableID,
			"Cidr Block":   &route.CidrBlock,
		}).Error("Error Creating Route")
		success = false
		err = append(err, rtErr)
	} else {
		//Route Added
		if createRouteOutput.Return != nil {
			log.WithFields(log.Fields{
				"RouteId":    routeTableID,
				"Cidr Block": route.CidrBlock,
			}).Info("Route Added to Route Table")
			success = true
		} else {
			success = false
			err = append(err, errors.New("Route to Route Table not created, this could cause issues creating to VM's"))
		}
	}
	return success, warnings, err
}

func (be *AwsVpcBackend) createRoute(routeTableID, instanceID, subnet string, ec2c *ec2.EC2) (*ec2.CreateRouteOutput, error) {
	route := &ec2.CreateRouteInput{
		RouteTableId:         &routeTableID,
		InstanceId:           &instanceID,
		DestinationCidrBlock: &subnet,
	}

	return ec2c.CreateRoute(route)
}

func createGateway(svc *ec2.EC2, vpc *ec2.Vpc, subid *string) error {
	cigi := &ec2.CreateInternetGatewayInput{}
	cigo, err := svc.CreateInternetGateway(cigi)
	if err != nil {
		fmt.Println("Failed to create gateway.")
		return err
	}

	//fmt.Println("We have vpcid: " + *vpc.VpcId)
	_, err = svc.AttachInternetGateway(&ec2.AttachInternetGatewayInput{InternetGatewayId: cigo.InternetGateway.InternetGatewayId, VpcId: vpc.VpcId})
	if err != nil {
		fmt.Println("Failed to attach gateway.")
		return err
	}

	defr := "0.0.0.0/0"
	rtid, err := getMainRouteTableFromVPC(svc, vpc.VpcId)
	if err != nil {
		fmt.Println("Failed to get route table from VPC id.")
		panic(err)
	}
	cri := &ec2.CreateRouteInput{DestinationCidrBlock: &defr, GatewayId: cigo.InternetGateway.InternetGatewayId, RouteTableId: rtid}
	_, err = svc.CreateRoute(cri)
	//fmt.Println(cro)
	if err != nil {
		fmt.Println("Failed to create default route.")
		return err
	}

	arti := &ec2.AssociateRouteTableInput{RouteTableId: rtid, SubnetId: subid}
	_, err = svc.AssociateRouteTable(arti)
	//fmt.Println(arto)
	if err != nil {
		fmt.Println("Failed to associate subnet with route table.")
		return err
	}

	return nil

}

//.........這裏部分代碼省略.........
		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

}