126 lines
3.8 KiB
Markdown
126 lines
3.8 KiB
Markdown
<h1> Deploying Multiple VMs</h1>
|
|
|
|
<h2>Table of Contents</h2>
|
|
|
|
- [Introduction](#introduction)
|
|
- [Example](#example)
|
|
|
|
***
|
|
|
|
## Introduction
|
|
|
|
We show how to deploy multiple VMs with the Go client.
|
|
|
|
## Example
|
|
|
|
```go
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
|
|
"github.com/threefoldtech/tfgrid-sdk-go/grid-client/deployer"
|
|
"github.com/threefoldtech/tfgrid-sdk-go/grid-client/workloads"
|
|
"github.com/threefoldtech/tfgrid-sdk-go/grid-proxy/pkg/types"
|
|
"github.com/threefoldtech/zos/pkg/gridtypes"
|
|
)
|
|
|
|
func main() {
|
|
|
|
// Create Threefold plugin client
|
|
tfPluginClient, err := deployer.NewTFPluginClient(mnemonics, "sr25519", network, "", "", "", 0, true)
|
|
|
|
// Get a free node to deploy
|
|
freeMRU := uint64(2)
|
|
freeSRU := uint64(2)
|
|
status := "up"
|
|
filter := types.NodeFilter {
|
|
FreeMRU: &freeMRU,
|
|
FreeSRU: &freeSRU,
|
|
Status: &status,
|
|
}
|
|
nodeIDs, err := deployer.FilterNodes(tfPluginClient.GridProxyClient, filter)
|
|
nodeID1 := uint32(nodeIDs[0].NodeID)
|
|
nodeID2 := uint32(nodeIDs[1].NodeID)
|
|
|
|
// Create a new network to deploy
|
|
network := workloads.ZNet{
|
|
Name: "newNetwork",
|
|
Description: "A network to deploy",
|
|
Nodes: []uint32{nodeID1, nodeID2},
|
|
IPRange: gridtypes.NewIPNet(net.IPNet{
|
|
IP: net.IPv4(10, 1, 0, 0),
|
|
Mask: net.CIDRMask(16, 32),
|
|
}),
|
|
AddWGAccess: true,
|
|
}
|
|
|
|
// Create new VMs to deploy
|
|
vm1 := workloads.VM{
|
|
Name: "vm1",
|
|
Flist: "https://hub.grid.tf/tf-official-apps/base:latest.flist",
|
|
CPU: 2,
|
|
PublicIP: true,
|
|
Planetary: true,
|
|
Memory: 1024,
|
|
RootfsSize: 20 * 1024,
|
|
Entrypoint: "/sbin/zinit init",
|
|
EnvVars: map[string]string{
|
|
"SSH_KEY": publicKey,
|
|
},
|
|
IP: "10.20.2.5",
|
|
NetworkName: network.Name,
|
|
}
|
|
vm2 := workloads.VM{
|
|
Name: "vm2",
|
|
Flist: "https://hub.grid.tf/tf-official-apps/base:latest.flist",
|
|
CPU: 2,
|
|
PublicIP: true,
|
|
Planetary: true,
|
|
Memory: 1024,
|
|
RootfsSize: 20 * 1024,
|
|
Entrypoint: "/sbin/zinit init",
|
|
EnvVars: map[string]string{
|
|
"SSH_KEY": publicKey,
|
|
},
|
|
IP: "10.20.2.6",
|
|
NetworkName: network.Name,
|
|
}
|
|
|
|
// Deploy the network first
|
|
err = tfPluginClient.NetworkDeployer.Deploy(ctx, &network)
|
|
|
|
// Load the network using the state loader
|
|
// this loader should load the deployment as json then convert it to a deployment go object with workloads inside it
|
|
networkObj, err := tfPluginClient.State.LoadNetworkFromGrid(network.Name)
|
|
|
|
// Deploy the VM deployments
|
|
dl1 := workloads.NewDeployment("vm1", nodeID1, "", nil, network.Name, nil, nil, []workloads.VM{vm1}, nil)
|
|
dl2 := workloads.NewDeployment("vm2", nodeID2, "", nil, network.Name, nil, nil, []workloads.VM{vm2}, nil)
|
|
err = tfPluginClient.DeploymentDeployer.BatchDeploy(ctx, []*workloads.Deployment{&dl1, &dl2})
|
|
|
|
// Load the VMs using the state loader
|
|
vmObj1, err := tfPluginClient.State.LoadVMFromGrid(nodeID1, vm1.Name, dl1.Name)
|
|
vmObj2, err := tfPluginClient.State.LoadVMFromGrid(nodeID2, vm2.Name, dl2.Name)
|
|
|
|
// Print the VMs Yggdrasil IP
|
|
fmt.Println(vmObj1.YggIP)
|
|
fmt.Println(vmObj2.YggIP)
|
|
|
|
// Cancel the VM deployments
|
|
err = tfPluginClient.DeploymentDeployer.Cancel(ctx, &dl1)
|
|
err = tfPluginClient.DeploymentDeployer.Cancel(ctx, &dl2)
|
|
|
|
// Cancel the network
|
|
err = tfPluginClient.NetworkDeployer.Cancel(ctx, &network)
|
|
}
|
|
|
|
```
|
|
|
|
Running this code should result in two VMs deployed on two separate nodes while being on the same network and you should see an output like this:
|
|
|
|
```bash
|
|
300:e9c4:9048:57cf:f4e0:2343:f891:6037
|
|
300:e9c4:9048:57cf:6d98:42c6:a7bf:2e3f
|
|
```
|