getSnapshot function

Future<GetSnapshotResult> getSnapshot(
  1. GetSnapshotArgs args, {
  2. InvokeOptions? options,
})

Use this data source to get information about a DB Snapshot for use when provisioning DB instances

> NOTE: This data source does not apply to snapshots created on Aurora DB clusters. See the aws.rds.ClusterSnapshot data source for DB Cluster snapshots.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const prod = new aws.rds.Instance("prod", {
    allocatedStorage: 10,
    engine: "mysql",
    engineVersion: "5.6.17",
    instanceClass: aws.rds.InstanceType.T2_Micro,
    dbName: "mydb",
    username: "foo",
    password: "bar",
    dbSubnetGroupName: "my_database_subnet_group",
    parameterGroupName: "default.mysql5.6",
});
const latestProdSnapshot = aws.rds.getSnapshotOutput({
    dbInstanceIdentifier: prod.identifier,
    mostRecent: true,
});
// Use the latest production snapshot to create a dev instance.
const dev = new aws.rds.Instance("dev", {
    instanceClass: aws.rds.InstanceType.T2_Micro,
    dbName: "mydbdev",
    snapshotIdentifier: latestProdSnapshot.id,
}, {
    ignoreChanges: ["snapshotIdentifier"],
});
import pulumi
import pulumi_aws as aws

prod = aws.rds.Instance("prod",
    allocated_storage=10,
    engine="mysql",
    engine_version="5.6.17",
    instance_class=aws.rds.InstanceType.T2_MICRO,
    db_name="mydb",
    username="foo",
    password="bar",
    db_subnet_group_name="my_database_subnet_group",
    parameter_group_name="default.mysql5.6")
latest_prod_snapshot = aws.rds.get_snapshot_output(db_instance_identifier=prod.identifier,
    most_recent=True)
# Use the latest production snapshot to create a dev instance.
dev = aws.rds.Instance("dev",
    instance_class=aws.rds.InstanceType.T2_MICRO,
    db_name="mydbdev",
    snapshot_identifier=latest_prod_snapshot.id,
    opts = pulumi.ResourceOptions(ignore_changes=["snapshotIdentifier"]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var prod = new Aws.Rds.Instance("prod", new()
    {
        AllocatedStorage = 10,
        Engine = "mysql",
        EngineVersion = "5.6.17",
        InstanceClass = Aws.Rds.InstanceType.T2_Micro,
        DbName = "mydb",
        Username = "foo",
        Password = "bar",
        DbSubnetGroupName = "my_database_subnet_group",
        ParameterGroupName = "default.mysql5.6",
    });

    var latestProdSnapshot = Aws.Rds.GetSnapshot.Invoke(new()
    {
        DbInstanceIdentifier = prod.Identifier,
        MostRecent = true,
    });

    // Use the latest production snapshot to create a dev instance.
    var dev = new Aws.Rds.Instance("dev", new()
    {
        InstanceClass = Aws.Rds.InstanceType.T2_Micro,
        DbName = "mydbdev",
        SnapshotIdentifier = latestProdSnapshot.Apply(getSnapshotResult => getSnapshotResult.Id),
    }, new CustomResourceOptions
    {
        IgnoreChanges =
        {
            "snapshotIdentifier",
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/rds"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		prod, err := rds.NewInstance(ctx, "prod", &rds.InstanceArgs{
			AllocatedStorage:   pulumi.Int(10),
			Engine:             pulumi.String("mysql"),
			EngineVersion:      pulumi.String("5.6.17"),
			InstanceClass:      pulumi.String(rds.InstanceType_T2_Micro),
			DbName:             pulumi.String("mydb"),
			Username:           pulumi.String("foo"),
			Password:           pulumi.String("bar"),
			DbSubnetGroupName:  pulumi.String("my_database_subnet_group"),
			ParameterGroupName: pulumi.String("default.mysql5.6"),
		})
		if err != nil {
			return err
		}
		latestProdSnapshot := rds.LookupSnapshotOutput(ctx, rds.GetSnapshotOutputArgs{
			DbInstanceIdentifier: prod.Identifier,
			MostRecent:           pulumi.Bool(true),
		}, nil)
		// Use the latest production snapshot to create a dev instance.
		_, err = rds.NewInstance(ctx, "dev", &rds.InstanceArgs{
			InstanceClass:      pulumi.String(rds.InstanceType_T2_Micro),
			DbName:             pulumi.String("mydbdev"),
			SnapshotIdentifier: latestProdSnapshot.Id(),
		}, pulumi.IgnoreChanges([]string{
			"snapshotIdentifier",
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_rds_getsnapshot" "latestProdSnapshot" {
  db_instance_identifier = aws_rds_instance.prod.identifier
  most_recent            = true
}

resource "aws_rds_instance" "prod" {
  allocated_storage    = 10
  engine               = "mysql"
  engine_version       = "5.6.17"
  instance_class       = "db.t2.micro"
  db_name              = "mydb"
  username             = "foo"
  password             = "bar"
  db_subnet_group_name = "my_database_subnet_group"
  parameter_group_name = "default.mysql5.6"
}
# Use the latest production snapshot to create a dev instance.
resource "aws_rds_instance" "dev" {
  lifecycle {
    ignore_changes = [snapshotIdentifier]
  }
  instance_class      = "db.t2.micro"
  db_name             = "mydbdev"
  snapshot_identifier = data.aws_rds_getsnapshot.latestProdSnapshot.id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.rds.Instance;
import com.pulumi.aws.rds.InstanceArgs;
import com.pulumi.aws.rds.RdsFunctions;
import com.pulumi.aws.rds.inputs.GetSnapshotArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var prod = new Instance("prod", InstanceArgs.builder()
            .allocatedStorage(10)
            .engine("mysql")
            .engineVersion("5.6.17")
            .instanceClass("db.t2.micro")
            .dbName("mydb")
            .username("foo")
            .password("bar")
            .dbSubnetGroupName("my_database_subnet_group")
            .parameterGroupName("default.mysql5.6")
            .build());

        final var latestProdSnapshot = RdsFunctions.getSnapshot(GetSnapshotArgs.builder()
            .dbInstanceIdentifier(prod.identifier())
            .mostRecent(true)
            .build());

        // Use the latest production snapshot to create a dev instance.
        var dev = new Instance("dev", InstanceArgs.builder()
            .instanceClass("db.t2.micro")
            .dbName("mydbdev")
            .snapshotIdentifier(latestProdSnapshot.applyValue(_latestProdSnapshot -> _latestProdSnapshot.id()))
            .build(), CustomResourceOptions.builder()
                .ignoreChanges("snapshotIdentifier")
                .build());

    }
}
resources:
  prod:
    type: aws:rds:Instance
    properties:
      allocatedStorage: 10
      engine: mysql
      engineVersion: 5.6.17
      instanceClass: db.t2.micro
      dbName: mydb
      username: foo
      password: bar
      dbSubnetGroupName: my_database_subnet_group
      parameterGroupName: default.mysql5.6
  # Use the latest production snapshot to create a dev instance.
  dev:
    type: aws:rds:Instance
    properties:
      instanceClass: db.t2.micro
      dbName: mydbdev
      snapshotIdentifier: ${latestProdSnapshot.id}
    options:
      ignoreChanges:
        - snapshotIdentifier
variables:
  latestProdSnapshot:
    fn::invoke:
      function: aws:rds:getSnapshot
      arguments:
        dbInstanceIdentifier: ${prod.identifier}
        mostRecent: true

args Arguments passed to this invoke. Arguments for getSnapshot. options Invoke options controlling this call.

Implementation

Future<GetSnapshotResult> getSnapshot(
  GetSnapshotArgs args, {
  pulumi.InvokeOptions? options,
}) async {
  final deployment = pulumi.Deployment.instance;
  final result = await deployment.invoke<Map<String, dynamic>>(
    'aws:rds/getSnapshot:getSnapshot',
    args.toMap(),
    options: pulumi.toDeploymentInvokeOptions(options),
  );
  return GetSnapshotResult.fromMap(result);
}