late-energy-66663
01/03/2022, 5:30 PMbillowy-army-68599
01/03/2022, 5:46 PMlate-energy-66663
01/03/2022, 6:56 PMbillowy-army-68599
01/05/2022, 12:47 AMlate-energy-66663
01/05/2022, 12:53 AMbillowy-army-68599
01/05/2022, 2:40 AMpulumi destroy --target <urn>
late-energy-66663
01/05/2022, 11:59 AMbillowy-army-68599
01/05/2022, 4:06 PMpulumi stack -u
late-energy-66663
01/05/2022, 5:28 PMbillowy-army-68599
01/05/2022, 5:33 PMlate-energy-66663
01/07/2022, 1:21 AMfunc (ws *Webserver) GetIPAddress(ctx *pulumi.Context) pulumi.StringOutput {
// The public IP address is not allocated until the VM is running, so wait for that resource to create, and then
// lookup the IP address again to report its public IP.
ready := pulumi.All(ws.VM.ID(), ws.PublicIP.Name, ws.PublicIP.ResourceGroupName)
return ready.ApplyT(func(args []interface{}) (string, error) {
name := args[1].(string)
resourceGroupName := args[2].(string)
ip, err := network.GetPublicIP(ctx, &network.GetPublicIPArgs{
Name: name,
ResourceGroupName: resourceGroupName,
})
if err != nil {
return "", err
}
return ip.IpAddress, nil
}).(pulumi.StringOutput)
}
My Version for EC2
func (v *virtualMachinesService) GetIPAddress(ctx *pulumi.Context) pulumi.StringOutput {
vm := new(virtualmachines.VirtualMachines)
// The public IP address is not allocated until the VM is running, so wait for that resource to create, and then
// lookup the IP address again to report its public IP.
ready := pulumi.All(vm.Instance.ID(), vm.Instance.PublicIp)
return ready.ApplyT(func(args []interface{}) (string, error) {
pubip := args[1].(string)
ip, err := ec2.GetInstance(ctx, "web-server-www-",vm.Instance.ID(), &ec2.InstanceState{
PublicIp: pubip,
}
})
if err != nil {
return "", err
}
return ip.p, nil
}).(pulumi.StringOutput)
}
type VirtualMachines struct {
pulumi.ResourceState
PublicIP *ec2.Eip
NetworkInterface *ec2.NetworkInterface
VPC *ec2.Vpc
Instance *ec2.Instance
Internet_gateway *ec2.InternetGateway
Route *ec2.Route
GetAvailabilityZones *ec2.AvailabilityZoneGroup
Subnet *ec2.Subnet
SecurityGroup *ec2.SecurityGroup
}
billowy-army-68599
01/07/2022, 1:25 AMGetInstance
for AWS EC2 instances, you should have an output with the IP address already which you can store in a slicelate-energy-66663
01/07/2022, 1:26 AM// ctx.Export("ipAddress", srv.PublicIp)
// Export the resulting server's IP address and DNS name.
ctx.Export("publicIp", vm.Instance.PublicIp)
ctx.Export("publicHostName", vm.Instance.PublicDns)
func NewVirtualMachine(ctx *pulumi.Context, name string, args *virtualmachines.VirtualMachinesArgs, opts ...pulumi.ResourceOption) (*virtualmachines.VirtualMachines, error){
vm := &virtualmachines.VirtualMachines{}
err := ctx.RegisterComponentResource("virtual_machine", name, vm, opts...)
if err != nil {
return nil, err
}
stackName := ctx.Stack()
// Create a valid webserver security group
vm.SecurityGroup, err = ec2.NewSecurityGroup(ctx, "web-secgrp", &ec2.SecurityGroupArgs{
Ingress: ec2.SecurityGroupIngressArray{
ec2.SecurityGroupIngressArgs{
//Protocol: pulumi.String("tcp"),
Protocol: args.Protocol,
FromPort: <http://pulumi.Int|pulumi.Int>(80),
ToPort: <http://pulumi.Int|pulumi.Int>(80),
CidrBlocks: pulumi.StringArray{pulumi.String("0.0.0.0/0")},
},
},
})
if err != nil {
return nil, err
}
userData := pulumi.Sprintf(`#!/bin/bash
echo "Hello from stack %s" > index.html
nohup python -m SimpleHTTPServer 80 &`, stackName)
fmt.Println(args.InstanceType)
fmt.Println(args.NumberOfNodes)
for i := 1; i <= args.NumberOfNodes; i++ {
vm.Instance, err = ec2.NewInstance(ctx, fmt.Sprintf("web-server-www-%d", i), &ec2.InstanceArgs{
Tags: pulumi.StringMap{"Name": pulumi.String(fmt.Sprintf("web-server-www-%d", i))},
//InstanceType: pulumi.String("t3.large"),
InstanceType: args.InstanceType,
VpcSecurityGroupIds: pulumi.StringArray{vm.SecurityGroup.ID()},
Ami: pulumi.String("ami-0a24e25f7f758ff73"),
UserData: userData,
})
if err != nil {
panic("error creating ec2 instance")
}
}
// ctx.Export("ipAddress", srv.PublicIp)
// Export the resulting server's IP address and DNS name.
ctx.Export("publicIp", vm.Instance.PublicIp)
ctx.Export("publicHostName", vm.Instance.PublicDns)
return nil, nil
}
func(v *virtualMachinesService) GetDeployVMFunc(vm *virtualmachines.CreateVmReq) pulumi.RunFunc {
return func(ctx *pulumi.Context) error {
fmt.Println(vm.Protocol)
_ ,err := NewVirtualMachine(ctx,"ec2-vms", &virtualmachines.VirtualMachinesArgs{
Protocol: pulumi.String(vm.Protocol),
NumberOfNodes: vm.NumberOfNodes,
InstanceType : pulumi.String(vm.InstanceType),
})
if err != nil {
return err
}
fmt.Println(vm.NumberOfNodes)
// ctx.Export("URN", vm.URN())
return nil
}
}
// set out program for the deployment with the resulting network info
w.SetProgram(VirtualMachinesService.GetDeployVMFunc(vm))
fmt.Println("deploying vm webserver...")
// wire up our update to stream progress to stdout
stdoutStreamer := optup.ProgressStreams(os.Stdout)
res, err := s.Up(ctx, stdoutStreamer)
if err != nil {
fmt.Printf("Failed to deploy vm stack: %v\n", err)
os.Exit(1)
}
time.Sleep(60 * time.Second)
for key, element := range res.Outputs {
fmt.Println("key", key, "=>", element.Value)
}
fmt.Println("Update succeeded!")
for key, element := range res.Outputs {
fmt.Println("Key:", key, "=>", "Element:", element.Value)
}
fmt.Println("Update succeeded!")
//fmt.Printf("deployed server running at public IP %s\n", res.Outputs["ip"].Value.(string))
return nil
}
return ready.ApplyT(func(args []interface{}) (pulumi.StringOutput, error)
which i think waits for the resource to be ready .type VirtualMachines struct {
pulumi.ResourceState
PublicIP *ec2.Eip
NetworkInterface *ec2.NetworkInterface
VPC *ec2.Vpc
Instance *ec2.Instance
Internet_gateway *ec2.InternetGateway
Route *ec2.Route
GetAvailabilityZones *ec2.AvailabilityZoneGroup
Subnet *ec2.Subnet
SecurityGroup *ec2.SecurityGroup
}
type VirtualMachinesArgs struct {
// A required username for the VM login.
Username pulumi.StringInput
// A required encrypted password for the VM password.
Password pulumi.StringInput
// An optional boot script that the VM will use.
BootScript pulumi.StringInput
// An optional VM size; if unspecified, Standard_A0 (micro) will be used.
VMSize pulumi.StringInput
// A required Resource Group in which to create the VM
ResourceGroupName pulumi.StringInput
// A required Subnet in which to deploy the VM
SubnetID pulumi.StringInput
// A required Subnet in which to deploy the VM
CidrBlock pulumi.StringInput
// This value for VPC to enable DNS
EnableDnsHostnames pulumi.Bool
// A map of tags to assign to the resource. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
Tags pulumi.StringMapInput
//
DestinationCidrBlock pulumi.StringInput
// Specify true to indicate
// that instances launched into the subnet should be assigned
// a public IP address. Default is `false`.
MapPublicIpOnLaunch pulumi.Bool
Protocol pulumi.StringInput
// The instance type to use for the instance. Updates to this field will trigger a stop/start of the EC2 instance.
InstanceType pulumi.StringInput
// Number of Nodes
NumberOfNodes int
Workdir auto.LocalWorkspace
}
billowy-army-68599
01/07/2022, 4:41 AMGetInstance
unless there's something in that call that you need. You already get the IPs, so just push them into a sliceApplyT
to get the string valuelate-energy-66663
01/07/2022, 4:25 PMfunc idOutputArrayToIDArrayOutput(as []pulumi.IDOutput) pulumi.IDArrayOutput {
var outputs []interface{}
for _, a := range as {
outputs = append(outputs, a)
}
return pulumi.All(outputs...).ApplyIDArray(func(vs []interface{}) []pulumi.ID {
var results []pulumi.ID
for _, v := range vs {
results = append(results, v.(pulumi.ID))
}
return results
})
}
func idOutputArrayToIDArrayOutput(as []pulumi.IDOutput) pulumi.IDArrayOutput {
var outputs []interface{}
for _, a := range as {
outputs = append(outputs, a)
}
return pulumi.IDArrayOutput(pulumi.All(outputs...).ApplyT(func(vs []interface{}) []pulumi.ID {
var results []pulumi.ID
for _, v := range vs {
results = append(results, v.(pulumi.ID))
}
return results
}).(pulumi.AnyOutput))
}
pulumi:pulumi:Stack vpc-vpc-pulumi error: an unhandled error occurred: go inline source runtime error, an unhandled error occurred:: interface conversion: pulumi.Output is pulumi.IDArrayOutput, not pulumi.IDArrayArrayOutput
pulumi:pulumi:Stack vpc-vpc-pulumi **failed** 1 error
Diagnostics:
pulumi:pulumi:Stack (vpc-vpc-pulumi):
error: an unhandled error occurred: go inline source runtime error, an unhandled error occurred:: interface conversion: pulumi.Output is pulumi.IDArrayOutput, not pulumi.IDArrayArrayOutput
billowy-army-68599
01/11/2022, 12:02 AMlate-energy-66663
01/11/2022, 12:06 AM