- pulumi/login 
- pulumi/update:
 stack: [[stackname]]
 skip-preview: true
working_directory: infrastructure

pulumi:pulumi:Stack [[stackname]]  error: could not find node on the $PATH: exec: "node": executable file not found in $PATH
    pulumi:pulumi:Stack [[stackname]]  error: error reading from server: EOF
    pulumi:pulumi:Stack [[stackname]] **failed** 1 error; 1 message

Diagnostics:
  pulumi:pulumi:Stack ([[stackname]]):
    error: could not find node on the $PATH: exec: "node": executable file not found in $PATH

    error: error reading from server: EOF

pulumi update --stack [[stackname]] --cwd infrastructure --skip-preview

automation api

pulumi.yaml

const stack = await LocalWorkspace.selectStack(args)

cp_config = command.remote.CopyFile(
    'config',
    connection=connection,
    local_path='install.sh',
    remote_path='install.sh',
    opts=pulumi.ResourceOptions(depends_on=[vm]),
)

pulumi up

install.sh

pulumi config cp [key] [dest]

pulumi
   prod
   dev

➜  prod git:(master) pulumi stack ls
NAME              LAST UPDATE     RESOURCE COUNT
stack.prod*       16 minutes ago  1
stack.dev         n/a             n/a

pulumi config cp key1 <http://stack.dev|stack.dev>

pulumi [up|...]

error: Preview failed: unrecognized resource type (Read):

error: Preview failed: unrecognized resource type (Read): aws:rds/dbclustersnapshot:DBClusterSnapshot

token

Pulumi.example.yaml

kubernetes

config:
  gcp:project: "new"
  kubernetes:pod_range: "test"

config:
  pod_range:
    type: String

error: could not get cloud url: could not load current project: could not validate '/Users/me/workspace/pulumi/kubernetes/Pulumi.yaml': 8 errors occurred:
	* #/config/pod_range: oneOf failed
	* #/config/pod_range: expected string, but got object
	* #/config/pod_range: expected integer, but got object
	* #/config/pod_range: expected boolean, but got object
	* #/config/pod_range: expected array, but got object
	* #/config/pod_range: doesn't validate with '/$defs/configTypeDeclaration'
	* #/config/pod_range/type: doesn't validate with '/$defs/simpleConfigType'
	* #/config/pod_range/type: value must be one of "string", "integer", "boolean", "array"

config

:

_

AttributeError: module '<http://pulumi_azure_native.app|pulumi_azure_native.app>' has no attribute 'ManagedEnvironmentStorageResponsePropertiesArgs'

config = pulumi.Config();
location = config.require('location')

config = pulumi.Config();
test = config.require('gcp:project')

string

package main

import (
	ec2Classic "<http://github.com/pulumi/pulumi-aws/sdk/v5/go/aws/ec2|github.com/pulumi/pulumi-aws/sdk/v5/go/aws/ec2>"
	"<http://github.com/pulumi/pulumi/sdk/v3/go/pulumi|github.com/pulumi/pulumi/sdk/v3/go/pulumi>"
)

func main() {
	vpc, err := ec2Classic.NewVpc(ctx, "vpc", &ec2Classic.VpcArgs{
		CidrBlock:          pulumi.String(cidrRange),
		EnableDnsHostnames: pulumi.Bool(true),
		EnableDnsSupport:   pulumi.Bool(true),
	}, opts...)
	if err != nil {
		return nil, err
	}
	ctx.Export("vpc", vpc)

	rt, err := ec2Classic.LookupRouteTable(ctx, &ec2Classic.LookupRouteTableArgs{
		// VpcId: pulumi.StringRef(fmt.Sprintf("%s", vpc.ID())),
		Filters: []ec2Classic.GetRouteTableFilter{
			{
				Name:   "vpc-id",
				Values: []string{"vpc-0497cc4ca5e669e0c"}, // how do I get the actual string value from vpc.ID()??
			},
			{
				Name:   "association.main",
				Values: []string{"true"},
			},
		},
	})
}

➜  testing-server ./tf2pulumi --target-language python
2023/01/13 12:31:25 [TRACE] module source: "git::git@github.com:gruntwork-io/terraform-aws-asg.git//modules/server-group?ref=v0.8.7"
2023/01/13 12:31:25 [TRACE] detected module source "git::<ssh://git@github.com/gruntwork-io/terraform-aws-asg.git?ref=v0.8.7>"
2023/01/13 12:31:25 [DEBUG] fetching module from git::<ssh://git@github.com/gruntwork-io/terraform-aws-asg.git?ref=v0.8.7>
2023/01/13 12:31:25 [DEBUG] found "git::<ssh://git@github.com/gruntwork-io/terraform-aws-asg.git?ref=v0.8.7>" in "": false
error: failed to load module: module servers: not found, may need to run 'terraform init'

"Property 'apigateway' does not exist on type 'typeof import(\"/Users/byronmartinez/Desktop/New Pulumi

<http://example.com|example.com>

<https://example.com>

<https://www.example.com>

<https://example.com>

// Step 2: Define the Networking for our service.
const alb = new awsx.elasticloadbalancingv2.ApplicationLoadBalancer(
    "net-lb",{
        external: true,
        vpc,
        subnets: vpcData.subnets.public,
        securityGroups: cluster.securityGroups,
    });

// Target group with the port of the Docker image
const target = alb.createTargetGroup(
    "web-target", {vpc, port: PORT}
);
// Listen to traffic on port 443 & route it through the target group
const httpsListener = target.createListener("web-listener", {
    port: 443,
    certificateArn: certificateValidation.certificateArn
});

const web = alb.createListener("nginx", {
    // const web = new awsx.elasticloadbalancingv2.ApplicationListener("nginx", {
    port: PORT,
    protocol: "HTTP",
    defaultAction: {
        type: "redirect",
        redirect: {
            protocol: "HTTPS",
            host: `${DOMAIN}`,
            port: "443",
            statusCode: "HTTP_301"
        },
    },
})

new aws.route53.Record(`<http://example.com|example.com>`, {
    name: `<http://example.com|example.com>`,
    zoneId: hostedZoneId,
    type: "A",
    aliases: [{
        name: httpsListener.endpoint.hostname,
        zoneId: alb.loadBalancer.zoneId,
        evaluateTargetHealth: true
    }],
});

Diagnostics:
  pulumi:pulumi:Stack (pulumi-storage-dev):
    error: an unhandled error occurred: Program exited with non-zero exit code: 82

    Unhandled exception. System.InvalidOperationException: Program run without the Pulumi engine available; re-run using the `pulumi` CLI
       at Pulumi.Deployment..ctor(RunnerOptions runnerOptions)
       at Pulumi.Deployment.<>c.<RunAsync>b__110_0()
       at Pulumi.Deployment.CreateRunnerAndRunAsync(Func`1 deploymentFactory, Func`2 runAsync)
       at Program.<Main>$(String[] args) in C:\Users\randy\source\repos\pulumi-storage\Program.cs:line 7
       at Program.<Main>(String[] args)