Пример #1
0
        private static async Task <WorkspaceStack> InitializeStack(Func <IDictionary <string, object?> > program)
        {
            var pulumiFn    = PulumiFn.Create(program);
            var projectName = $"{typeof(StandardVpcTests)}-{nameof(CanDeploy)}";
            var stackName   = "test";
            var stackArgs   = new InlineProgramArgs(projectName, stackName, pulumiFn);

            stackArgs.ConfigureForLocalBackend();
            var stack = await LocalWorkspace.CreateOrSelectStackAsync(stackArgs);

            await stack.Workspace.InstallPluginAsync <Provider>();

            await stack.SetConfigAsync("aws:region", new ConfigValue("eu-west-1"));

            return(stack);
        }
Пример #2
0
        static async Task Main(string[] args)
        {
            // define our pulumi program "inline"
            var program = PulumiFn.Create(() =>
            {
                // get default vpc
                var defaultVpc = Output.Create(Pulumi.Aws.Ec2.GetVpc.InvokeAsync(new Pulumi.Aws.Ec2.GetVpcArgs
                {
                    Default = true,
                }));

                // get public subnets
                var publicSubnetIds = defaultVpc.Apply(vpc =>
                {
                    return(Output.Create(Pulumi.Aws.Ec2.GetSubnetIds.InvokeAsync(new Pulumi.Aws.Ec2.GetSubnetIdsArgs
                    {
                        VpcId = vpc.Id,
                    })));
                });

                var subnetGroup = new Pulumi.Aws.Rds.SubnetGroup(
                    "db-subnet",
                    new Pulumi.Aws.Rds.SubnetGroupArgs
                {
                    SubnetIds = publicSubnetIds.Apply(x => x.Ids),
                });

                // make a public security group for our cluster for the migration
                var securityGroup = new Pulumi.Aws.Ec2.SecurityGroup(
                    "public-security-group",
                    new Pulumi.Aws.Ec2.SecurityGroupArgs
                {
                    Ingress = new Pulumi.Aws.Ec2.Inputs.SecurityGroupIngressArgs
                    {
                        Protocol   = "-1",
                        FromPort   = 0,
                        ToPort     = 0,
                        CidrBlocks = "0.0.0.0/0"
                    },
                    Egress = new Pulumi.Aws.Ec2.Inputs.SecurityGroupEgressArgs
                    {
                        Protocol   = "-1",
                        FromPort   = 0,
                        ToPort     = 0,
                        CidrBlocks = "0.0.0.0/0",
                    },
                });

                // for example, you should change this
                var dbName     = "hellosql";
                var dbUser     = "******";
                var dbPassword = "******";

                // provision our db
                var cluster = new Pulumi.Aws.Rds.Cluster(
                    "db",
                    new Pulumi.Aws.Rds.ClusterArgs
                {
                    Engine              = Pulumi.Aws.Rds.EngineType.AuroraMysql,
                    EngineVersion       = "5.7.mysql_aurora.2.03.2",
                    DatabaseName        = dbName,
                    MasterUsername      = dbUser,
                    MasterPassword      = dbPassword,
                    SkipFinalSnapshot   = true,
                    DbSubnetGroupName   = subnetGroup.Name,
                    VpcSecurityGroupIds = securityGroup.Id,
                });

                var clusterInstance = new Pulumi.Aws.Rds.ClusterInstance(
                    "db-instance",
                    new Pulumi.Aws.Rds.ClusterInstanceArgs
                {
                    ClusterIdentifier  = cluster.ClusterIdentifier,
                    InstanceClass      = Pulumi.Aws.Rds.InstanceType.T3_Small,
                    Engine             = Pulumi.Aws.Rds.EngineType.AuroraMysql.ToString(),
                    EngineVersion      = "5.7.mysql_aurora.2.03.2",
                    PubliclyAccessible = true,
                    DbSubnetGroupName  = subnetGroup.Name,
                });

                // export the website url
                return(new Dictionary <string, object?>
                {
                    ["host"] = cluster.Endpoint,
                    ["db_name"] = dbName,
                    ["db_user"] = dbUser,
                    ["db_pass"] = dbPassword,
                });
            });

            // to destroy our program, we can run "dotnet run destroy"
            var destroy = args.Any() && args[0] == "destroy";

            var projectName = "database_migration_project";
            var stackName   = "dev";

            // create or select a stack matching the specified name and project
            // this will set up a workspace with everything necessary to run our inline program (program)
            var stackArgs = new InlineProgramArgs(projectName, stackName, program);
            var stack     = await LocalWorkspace.CreateOrSelectStackAsync(stackArgs);

            Console.WriteLine("successfully initialized stack");

            // for inline programs, we must manage plugins ourselves
            Console.WriteLine("installing plugins...");
            await stack.Workspace.InstallPluginAsync("aws", "v4.24.1");

            Console.WriteLine("plugins installed");

            // set stack configuration specifying the region to deploy
            Console.WriteLine("setting up config...");
            await stack.SetConfigAsync("aws:region", new ConfigValue("us-west-2"));

            Console.WriteLine("config set");

            Console.WriteLine("refreshing stack...");
            await stack.RefreshAsync(new RefreshOptions { OnStandardOutput = Console.WriteLine });

            Console.WriteLine("refresh complete");

            if (destroy)
            {
                Console.WriteLine("destroying stack...");
                await stack.DestroyAsync(new DestroyOptions { OnStandardOutput = Console.WriteLine });

                Console.WriteLine("stack destroy complete");
                return;
            }

            Console.WriteLine("updating stack...");
            var result = await stack.UpAsync(new UpOptions { OnStandardOutput = Console.WriteLine });

            if (result.Summary.ResourceChanges != null)
            {
                Console.WriteLine("update summary:");
                foreach (var change in result.Summary.ResourceChanges)
                {
                    Console.WriteLine($"    {change.Key}: {change.Value}");
                }
            }

            Console.WriteLine($"db host url: {result.Outputs["host"].Value}");

            Console.WriteLine("configuring db...");
            var connectionStr = $"Server={result.Outputs["host"].Value};Database={result.Outputs["db_name"].Value};Uid={result.Outputs["db_user"].Value};Pwd={result.Outputs["db_pass"].Value};";

            using var connection = new MySqlConnection(connectionStr);
            await connection.OpenAsync();

            Console.WriteLine("db configured!");

            // make sure the table exists
            const string createTableQuery = @"
CREATE TABLE IF NOT EXISTS hello_pulumi(
id int(9) NOT NULL PRIMARY KEY,
color varchar(14) NOT NULL);";

            using var createCommand = new MySqlCommand(createTableQuery, connection);
            await createCommand.ExecuteNonQueryAsync();

            // seed the table with some data to start
            const string seedTableQuery = @"
INSERT IGNORE INTO hello_pulumi (id, color)
VALUES
    (1, 'Purple'),
    (2, 'Violet'),
    (3, 'Plum');";

            using var seedCommand = new MySqlCommand(seedTableQuery, connection);
            await seedCommand.ExecuteNonQueryAsync();

            Console.WriteLine("rows inserted!");
            Console.WriteLine("querying to verify data...");

            const string readTableQuery = "SELECT COUNT(*) FROM hello_pulumi;";

            using var readCommand = new MySqlCommand(readTableQuery, connection);
            var readResult = await readCommand.ExecuteScalarAsync();

            Console.WriteLine($"Result: {readResult} rows");

            Console.WriteLine("database, table, and rows successfully configured");
        }
Пример #3
0
        static async Task Main(string[] args)
        {
            // define our pulumi program "inline"
            var program = PulumiFn.Create(() =>
            {
                // create a bucket and expose a website index document
                var siteBucket = new Pulumi.Aws.S3.Bucket(
                    "s3-website-bucket",
                    new Pulumi.Aws.S3.BucketArgs
                {
                    Website = new Pulumi.Aws.S3.Inputs.BucketWebsiteArgs
                    {
                        IndexDocument = "index.html",
                    },
                });

                const string indexContent = @"
<html>
    <head><titl>Hello S3</title><meta charset=""UTF-8""></head>
    <body>
        <p>Hello, world!</p>
        <p>Made with ❤️ with <a href=""https://pulumi.com"">Pulumi</a></p>
    </body>
</html>
";

                // write our index.html into the site bucket
                var @object = new Pulumi.Aws.S3.BucketObject(
                    "index",
                    new Pulumi.Aws.S3.BucketObjectArgs
                {
                    Bucket      = siteBucket.BucketName,      // reference to the s3 bucket object
                    Content     = indexContent,
                    Key         = "index.html",               // set the key of the object
                    ContentType = "text/html; charset=utf-8", // set the MIME type of the file
                });

                var bucketPolicyDocument = siteBucket.Arn.Apply(bucketArn =>
                {
                    return(Output.Create(Pulumi.Aws.Iam.GetPolicyDocument.InvokeAsync(
                                             new Pulumi.Aws.Iam.GetPolicyDocumentArgs
                    {
                        Statements = new List <Pulumi.Aws.Iam.Inputs.GetPolicyDocumentStatementArgs>
                        {
                            new Pulumi.Aws.Iam.Inputs.GetPolicyDocumentStatementArgs
                            {
                                Effect = "Allow",
                                Principals = new List <Pulumi.Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalArgs>
                                {
                                    new Pulumi.Aws.Iam.Inputs.GetPolicyDocumentStatementPrincipalArgs
                                    {
                                        Identifiers = new List <string> {
                                            "*"
                                        },
                                        Type = "AWS",
                                    },
                                },
                                Actions = new List <string> {
                                    "s3:GetObject"
                                },
                                Resources = new List <string> {
                                    $"{bucketArn}/*"
                                },
                            },
                        },
                    })));
                });

                // set the access policy for the bucket so all objects are readable
                new Pulumi.Aws.S3.BucketPolicy(
                    "bucket-policy",
                    new Pulumi.Aws.S3.BucketPolicyArgs
                {
                    Bucket = siteBucket.BucketName,
                    Policy = bucketPolicyDocument.Apply(x => x.Json),
                });

                // export the website url
                return(new Dictionary <string, object?>
                {
                    ["secret"] = Pulumi.Output.CreateSecret("hello world"),
                    ["website_url"] = siteBucket.WebsiteEndpoint,
                });
            });

            // to destroy our program, we can run "dotnet run destroy"
            var destroy = args.Any() && args[0] == "destroy";

            var projectName     = "inline_s3_project";
            var stackName       = "dev";
            var secretsProvider = "awskms://aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee?region=us-west-2";
            var keyId           = System.Environment.GetEnvironmentVariable("KMS_KEY");

            if (keyId != null)
            {
                secretsProvider = "awskms://" + keyId + "?region=" + System.Environment.GetEnvironmentVariable("AWS_REGION");
            }

            if (secretsProvider == "awskms://aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee?region=us-west-2")
            {
                throw new Exception("Update secretsProvider to use an actual AWS KMS key.");
            }

            // create or select a stack matching the specified name and project
            // this will set up a workspace with everything necessary to run our inline program (program)
            var stackArgs = new InlineProgramArgs(projectName, stackName, program);

            stackArgs.SecretsProvider = secretsProvider;
            stackArgs.StackSettings   = new Dictionary <string, StackSettings>()
            {
                [stackName] = new StackSettings()
                {
                    SecretsProvider = secretsProvider
                }
            };

            var stack = await LocalWorkspace.CreateOrSelectStackAsync(stackArgs);

            Console.WriteLine("successfully initialized stack");

            // for inline programs, we must manage plugins ourselves
            Console.WriteLine("installing plugins...");
            await stack.Workspace.InstallPluginAsync("aws", "v4.24.1");

            Console.WriteLine("plugins installed");

            // set stack configuration specifying the region to deploy
            Console.WriteLine("setting up config...");
            await stack.SetConfigAsync("aws:region", new ConfigValue("us-west-2"));

            Console.WriteLine("config set");

            Console.WriteLine("refreshing stack...");
            await stack.RefreshAsync(new RefreshOptions { OnStandardOutput = Console.WriteLine });

            Console.WriteLine("refresh complete");

            if (destroy)
            {
                Console.WriteLine("destroying stack...");
                await stack.DestroyAsync(new DestroyOptions { OnStandardOutput = Console.WriteLine });

                Console.WriteLine("stack destroy complete");
            }
            else
            {
                Console.WriteLine("updating stack...");
                var result = await stack.UpAsync(new UpOptions { OnStandardOutput = Console.WriteLine });

                if (result.Summary.ResourceChanges != null)
                {
                    Console.WriteLine("update summary:");
                    foreach (var change in result.Summary.ResourceChanges)
                    {
                        Console.WriteLine($"    {change.Key}: {change.Value}");
                    }
                }

                Console.WriteLine($"website url: {result.Outputs["website_url"].Value}");
            }
        }