Пример #1
0
// Create a machine instance
func (vp *vultrProvider) CreateInstance(log *logging.Logger, options providers.CreateInstanceOptions, dnsProvider providers.DnsProvider) (providers.ClusterInstance, error) {
	// Create server
	id, err := vp.createServer(options)
	if err != nil {
		return providers.ClusterInstance{}, maskAny(err)
	}

	// Wait for the server to be active
	server, err := vp.waitUntilServerActive(id)
	if err != nil {
		return providers.ClusterInstance{}, maskAny(err)
	}

	privateIpv4 := server.InternalIP
	publicIpv4 := server.MainIP
	publicIpv6 := ""
	if len(server.V6Networks) > 0 {
		publicIpv6 = server.V6Networks[0].MainIP
	}
	if err := providers.RegisterInstance(vp.Logger, dnsProvider, options, server.Name, options.RegisterInstance, options.RoleLoadBalancer, options.RoleLoadBalancer, publicIpv4, publicIpv6, privateIpv4); err != nil {
		return providers.ClusterInstance{}, maskAny(err)
	}

	vp.Logger.Infof("Server '%s' is ready", server.Name)

	return vp.clusterInstance(server), nil
}
Пример #2
0
// createInstance creates a new instances, runs the bootstrap script and registers the instance
// in DNS.
func (vp *scalewayProvider) createInstance(log *logging.Logger, options providers.CreateInstanceOptions, dnsProvider providers.DnsProvider, existingInstances providers.ClusterInstanceList) (providers.ClusterInstance, error) {
	if options.RegionID != vp.Region {
		return providers.ClusterInstance{}, maskAny(fmt.Errorf("Cannot create server on region '%s' with provider configured for region '%s", options.RegionID, vp.Region))
	}
	// Create a new machine ID
	machineID, err := util.GenUUID()
	if err != nil {
		return providers.ClusterInstance{}, maskAny(err)
	}
	log.Debugf("created machined-id: %s", machineID)

	// Create server
	instance, err := vp.createAndStartServer(options)
	if err != nil {
		return providers.ClusterInstance{}, maskAny(err)
	}

	// Update `cluster-members` file on existing instances.
	// This ensures that the firewall of the existing instances allows our new instance
	if len(existingInstances) > 0 {
		rebootAfter := false
		clusterMembers, err := existingInstances.AsClusterMemberList(log, nil)
		if err != nil {
			return providers.ClusterInstance{}, maskAny(err)
		}
		newMember := providers.ClusterMember{
			ClusterID:     options.ClusterInfo.ID,
			MachineID:     machineID,
			ClusterIP:     instance.ClusterIP,
			PrivateHostIP: instance.PrivateIP,
			EtcdProxy:     options.EtcdProxy,
		}
		clusterMembers = append(clusterMembers, newMember)
		if err := existingInstances.UpdateClusterMembers(log, clusterMembers, rebootAfter, vp); err != nil {
			log.Warningf("Failed to update cluster members: %#v", err)
		}
	}

	// Bootstrap server
	if err := vp.bootstrapServer(instance, options, machineID); err != nil {
		return providers.ClusterInstance{}, maskAny(err)
	}

	// Wait for the server to be active
	server, err := vp.waitUntilServerActive(instance.ID, false)
	if err != nil {
		return providers.ClusterInstance{}, maskAny(err)
	}

	if options.RoleLoadBalancer {
		privateIpv4 := server.PrivateIP
		publicIpv4 := server.PublicAddress.IP
		publicIpv6 := ""
		if server.IPV6 != nil {
			publicIpv6 = server.IPV6.Address
		}
		if err := providers.RegisterInstance(vp.Logger, dnsProvider, options, server.Name, options.RegisterInstance, options.RoleLoadBalancer, options.RoleLoadBalancer, publicIpv4, publicIpv6, privateIpv4); err != nil {
			return providers.ClusterInstance{}, maskAny(err)
		}
	}

	vp.Logger.Infof("Server '%s' is ready", server.Name)

	return vp.clusterInstance(server, false), nil
}
Пример #3
0
func (dp *doProvider) CreateInstance(log *logging.Logger, options providers.CreateInstanceOptions, dnsProvider providers.DnsProvider) (providers.ClusterInstance, error) {
	client := NewDOClient(dp.token)

	keys := []godo.DropletCreateSSHKey{}
	listedKeys, err := KeyList(client)
	if err != nil {
		return providers.ClusterInstance{}, maskAny(err)
	}
	for _, key := range options.SSHKeyNames {
		k := findKeyID(key, listedKeys)
		if k == nil {
			return providers.ClusterInstance{}, maskAny(errors.New("Key not found"))
		}
		keys = append(keys, godo.DropletCreateSSHKey{ID: k.ID})
	}

	opts := options.NewCloudConfigOptions()
	opts.PrivateIPv4 = "$private_ipv4"

	cloudConfig, err := templates.Render(cloudConfigTemplate, opts)
	if err != nil {
		return providers.ClusterInstance{}, maskAny(err)
	}

	request := &godo.DropletCreateRequest{
		Name:              options.InstanceName,
		Region:            options.RegionID,
		Size:              options.TypeID,
		Image:             godo.DropletCreateImage{Slug: options.ImageID},
		SSHKeys:           keys,
		Backups:           false,
		IPv6:              true,
		PrivateNetworking: true,
		UserData:          cloudConfig,
	}

	// Create droplet
	dp.Logger.Infof("Creating droplet: %s, %s, %s", request.Region, request.Size, options.ImageID)
	dp.Logger.Debugf(cloudConfig)
	createDroplet, _, err := client.Droplets.Create(request)
	if err != nil {
		return providers.ClusterInstance{}, maskAny(err)
	}

	// Wait for active
	dp.Logger.Infof("Waiting for droplet '%s'", createDroplet.Name)
	droplet, err := dp.waitUntilDropletActive(createDroplet.ID)
	if err != nil {
		return providers.ClusterInstance{}, maskAny(err)
	}

	privateIpv4 := getIpv4(*droplet, "private")
	publicIpv4 := getIpv4(*droplet, "public")
	publicIpv6 := getIpv6(*droplet, "public")
	if err := providers.RegisterInstance(dp.Logger, dnsProvider, options, createDroplet.Name, options.RegisterInstance, options.RoleLoadBalancer, options.RoleLoadBalancer, publicIpv4, publicIpv6, privateIpv4); err != nil {
		return providers.ClusterInstance{}, maskAny(err)
	}

	dp.Logger.Infof("Droplet '%s' is ready", createDroplet.Name)

	return dp.clusterInstance(*droplet), nil
}