### StackSet Deploy Configuration Example (YAML)

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_stackset_deploy.md

An example of a YAML configuration file for 'rain stackset deploy'. This file can specify parameters, tags, stack set details, and instance configurations for accounts and regions.

```yaml
Parameters:
	Name: Value
Tags:
	Name: Value
StackSet:
	description: "test description"
	...
StackSetInstances:
	accounts:
		- "123456789123"
	regions:
		- us-east-1
		- us-east-2
		...

```

--------------------------------

### YAML Configuration File Example

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_deploy.md

This is an example of a YAML configuration file for setting stack parameters and tags. It offers an alternative format to JSON for the same purpose. Values in this file can be overridden by command-line flags.

```yaml
Parameters:
  NameOfTemplateParameter: ValueOfParameter
  ...
Tags:
  TagKey: TagValue
  ...
```

--------------------------------

### JSON Configuration File Example

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_deploy.md

This is an example of a JSON configuration file used to specify parameters and tags for a CloudFormation stack deployment. Command-line arguments will override values set in this file.

```json
{
  "Parameters" : {
    "NameOfTemplateParameter" : "ValueOfParameter",
    ...
  },
  "Tags" : {
    "TagKey" : "TagValue",
    ...
  }
}
```

--------------------------------

### Display Rain Version

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_version.md

Use this command to display the installed version of the rain tool. No additional arguments or setup are required.

```bash
rain version
```

--------------------------------

### Rain Module Install Options

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_module_install.md

These options configure the installation process, such as enabling debug output, specifying the CodeArtifact domain and repository, and setting the target AWS region or profile.

```bash
--debug            Output debugging information
```

```bash
--domain string    The CodeArtifact domain (default "cloudformation")
```

```bash
-x, --experimental     Acknowledge that this is an experimental feature
```

```bash
-h, --help             help for install
```

```bash
--path string      The local path for module files, defaults to the current directory (default ".")
```

```bash
-p, --profile string   AWS profile name; read from the AWS CLI configuration file
```

```bash
-r, --region string    AWS region to use
```

```bash
--repo string      The CodeArtifact repository (default "rain")
```

```bash
--version string   Version of the module to install
```

--------------------------------

### Pkl CloudFormation Template Example

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

Example of a CloudFormation template written in Pkl, demonstrating type-safe resource definition and imports from the cloudformation-pkl package.

```pkl
amends "package://github.com/aws-cloudformation/cloudformation-pkl/releases/download/cloudformation@0.1.1/cloudformation@0.1.1#/template.pkl"
import "package://github.com/aws-cloudformation/cloudformation-pkl/releases/download/cloudformation@0.1.1/cloudformation@0.1.1#/cloudformation.pkl" as cfn
import "package://github.com/aws-cloudformation/cloudformation-pkl/releases/download/cloudformation@0.1.1/cloudformation@0.1.1#/aws/s3/bucket.pkl" as bucket

Description = "Create a bucket"

Parameters {
    ["Name"] {
        Type = "String"
        Default = "baz"
    }
}

Resources {
    ["MyBucket"] = new bucket.Bucket {
        BucketName = cfn.Ref("Name")
    }
}
```

--------------------------------

### Install a Rain Module

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_module_install.md

Use this command to install a package of Rain modules from CodeArtifact. Specify the module name and any desired flags for customization.

```bash
rain module install <name> [flags]
```

--------------------------------

### Process CloudFormation Template with Installed Modules

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Processes a CloudFormation template that references installed Rain modules.

```bash
rain pkg template.yaml --experimental
```

--------------------------------

### Reference Installed Module in CloudFormation Template

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Example of how to reference an installed Rain module within a CloudFormation template using the '$' prefix for the module source.

```yaml
Modules:
  Vpc:
    Source: $my-modules/simple-vpc.yaml
    Properties:
      Env: prod
```

--------------------------------

### Inherited Options for Rain Module Install

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_module_install.md

This option is inherited from parent commands and controls the output format.

```bash
--no-colour   Disable colour output
```

--------------------------------

### Install Rain Modules from CodeArtifact

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Downloads and installs a package of Rain modules from AWS CodeArtifact. Specify the target path, version, domain, and repository.

```bash
rain module install my-modules --experimental \
  --version 1.2.0 \
  --path ./installed-modules \
  --domain cloudformation \
  --repo rain
```

--------------------------------

### Rain Artifacts Bucket Structure

Source: https://github.com/aws-cloudformation/rain/blob/main/internal/cmd/cc/README.md

An example of the directory structure within the rain artifacts bucket, showing how deployment state files are organized by name and region.

```text
rain-artifacts-0123456789012-us-east-1/ 
    deployments/ 
        name1.yaml
        name2.yaml
```

--------------------------------

### Display Current AWS Configuration

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_info.md

Use this command to view the AWS account and region you are currently configured to use. No setup or imports are required.

```bash
rain info
```

--------------------------------

### Bootstrap CodeArtifact Domain and Repository

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Initializes the AWS CodeArtifact domain and repository for managing Rain modules. This is a one-time setup.

```bash
rain module bootstrap --experimental
```

--------------------------------

### Implement a Custom Forecast Plugin

Source: https://github.com/aws-cloudformation/rain/blob/main/internal/cmd/forecast/README.md

Example of a Go plugin for the rain forecast command. This plugin implements a prediction function for AWS::Lambda::Function resources.

```go
package main

import (
	fc "github.com/aws-cloudformation/rain/plugins/forecast"
)

type PluginImpl struct{}

// A sample prediction function.
func predictLambda(input fc.PredictionInput) fc.Forecast {
	forecast := fc.MakeForecast(&input)

	// Implement whatever checks you want to make here
	forecast.Add("CODE", false, "testing plugin", 0)

	return forecast
}

// GetForecasters must be implemented by forecast plugins
// This function returns all predictions functions implemented by the plugin
func (p *PluginImpl) GetForecasters() map[string]func(input fc.PredictionInput) fc.Forecast {
	retval := make(map[string]func(input fc.PredictionInput) fc.Forecast)

	retval["AWS::Lambda::Function"] = predictLambda

	return retval
}

// Leave main empty
func main() {
}

// This variable is required to allow rain to find the implementation
var Plugin = PluginImpl{}

```

--------------------------------

### Parse CloudFormation Templates from File, String, or Reader

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Use `parse.File`, `parse.String`, or `parse.Reader` to load CloudFormation templates into a `*cft.Template` for manipulation. The `*cft.Template` object provides methods to check for sections, retrieve resources, and get resource types.

```go
package main

import (
    "fmt"
    "os"

    "github.com/aws-cloudformation/rain/cft/parse"
    "github.com/aws-cloudformation/rain/cft/format"
)

func main() {
    // Parse from a file path
    t, err := parse.File("template.yaml")
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }
    fmt.Println("Template name:", t.Name)

    // Parse from a YAML/JSON string
    tStr, err := parse.String(`
AWSTemplateFormatVersion: "2010-09-09"
Resources:
  MyBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: my-test-bucket
`)
    if err != nil {
        panic(err)
    }

    // Check for a section
    if tStr.HasSection("Resources") {
        fmt.Println("Has Resources section")
    }

    // Get a specific resource node
    node, err := tStr.GetResource("MyBucket")
    if err != nil {
        panic(err)
    }
    fmt.Printf("MyBucket node kind: %d\n", node.Kind)

    // Get all resource types
    types, _ := tStr.GetTypes()
    fmt.Println("Types:", types) // [AWS::S3::Bucket]

    // Convert back to formatted YAML string
    yaml := format.CftToYaml(tStr)
    fmt.Print(yaml)

    // Parse from an io.Reader
    f, _ := os.Open("template.yaml")
    defer f.Close()
    tReader, _ := parse.Reader(f)
    _ = tReader

    // Verify semantic equivalence after round-tripping
    output := format.String(tStr, format.Options{JSON: false, Unsorted: false})
    if err := parse.Verify(tStr, output); err != nil {
        fmt.Println("Semantic difference detected:", err)
    } else {
        fmt.Println("Round-trip verified OK")
    }
}
```

--------------------------------

### Rain S3Http Directive Example

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

Demonstrates the !Rain::S3Http directive for uploading files or directories to S3 and inserting the HTTPS URL into the template. Rain will create an artifact bucket if one doesn't exist and use the default AWS profile.

```yaml
Resources:
  Test:
    Type: A::B::C
    Properties:
      TheS3URL: !Rain::S3Http s3http.txt
```

```yaml
Resources:
  Test:
    Type: A::B::C
    Properties:
      TheS3URL: https://rain-artifacts-012345678912-us-east-1.s3.us-east-1.amazonaws.com/a84b588aa54068ed4b027b6e06e5e0bb283f83cf0d5a6720002d36af2225dfc3
```

--------------------------------

### Rain Embed Directive Example

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

Demonstrates how to use the !Rain::Embed directive to insert file content into a CloudFormation template. Ensure the 'embed.txt' file is in the same directory as the template.

```yaml
Resources:
  Test:
    Type: AWS::CloudFormation::WaitConditionHandle
    Metadata:
      Comment: !Rain::Embed embed.txt
```

```txt
This is a test
```

```yaml
Resources:
  Test:
    Type: AWS::CloudFormation::WaitConditionHandle
    Metadata:
      Comment: This is a test
```

--------------------------------

### Download Deployed Templates with Rain Cat

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Use `rain cat` to download and print the deployed CloudFormation template for a stack. Options include getting the transformed template, the Rain config file, or the raw unformatted template. It can also be piped to `rain diff`.

```bash
rain cat my-stack
```

```bash
rain cat my-stack --transformed
```

```bash
rain cat my-stack --config
```

```bash
rain cat my-stack --unformatted
```

```bash
rain cat my-stack | rain diff - local-template.yaml
```

--------------------------------

### Deploy with Parameters and Skip Confirmation

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Deploys a template using Cloud Control API with specified parameters and bypasses the confirmation prompt.

```bash
rain cc deploy --experimental template.yaml my-deployment \
  --params BucketName=my-bucket \
  --yes
```

--------------------------------

### Using a Module with Properties and Overrides

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

Demonstrates how to use a module, passing properties and overriding specific resource configurations. The 'Overrides' attribute allows for fine-grained control over module content.

```yaml
Modules:
  Content:
    Source: ./module.yaml
    Properties:
      Name: foo
    Overrides:
      Bucket:
        Metadata:
          OverrideMe: def
Outputs:
  TheArn:
    Value: !GetAtt Content.BucketArn
```

--------------------------------

### Rain CC Deploy Command Syntax

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_cc_deploy.md

Use this command to create or update resources directly using the Cloud Control API from a specified template file. The --experimental flag must be used.

```bash
rain cc deploy <template> <name>
```

--------------------------------

### Download CloudFormation Stack Template

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_cat.md

Use this command to download the CloudFormation template of a running stack. Specify the stack name as an argument.

```bash
rain cat <stack>
```

--------------------------------

### Deploy Template via Cloud Control API

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Deploys resources directly using the AWS Cloud Control API, maintaining a local state file. Use the --experimental flag.

```bash
rain cc deploy --experimental template.yaml my-deployment
```

--------------------------------

### Enable experimental features

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_pkg.md

Use the -x or --experimental flag to enable experimental features, such as the !Rain::Module directive.

```bash
-x, --experimental
```

--------------------------------

### Watch CloudFormation Stack

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_watch.md

Repeatedly displays the status of a CloudFormation stack. Useful for watching the progress of a deployment started from outside of Rain.

```bash
rain watch <stack>
```

--------------------------------

### Upload to S3 with advanced options

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_pkg.md

Configure S3 uploads with options for zipping, specifying bucket/key properties, and output format (Uri or Http). This directive requires the 'BucketProperty' and 'KeyProperty' to be defined.

```yaml
!Rain::S3 <object>
  Path: <path>
  Zip: true|false
  BucketProperty: <bucket>
  KeyProperty: <key>
  Format: Uri|Http
```

--------------------------------

### List Stack Sets with Options

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_stackset_ls.md

These options modify the behavior of the 'rain stackset ls' command. Use '--all' to list stacks in all regions or to show more details when a stack set name is specified. Use '--profile' to specify an AWS profile and '--region' to set the AWS region.

```bash
rain stackset ls <stack set> --admin
```

```bash
rain stackset ls <stack set> -a, --all
```

```bash
rain stackset ls <stack set> -p string, --profile string
```

```bash
rain stackset ls <stack set> -r string, --region string
```

--------------------------------

### StackSet Deploy Command Syntax

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_stackset_deploy.md

The basic syntax for deploying a CloudFormation stack set using the rain CLI. Specify the template file and optionally the stack set name.

```bash
rain stackset deploy <template> [stackset] [flags]
```

--------------------------------

### Output packaged template to file

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_pkg.md

Use the -o or --output flag to specify a file path for saving the packaged CloudFormation template.

```bash
-o, --output string
```

--------------------------------

### Define Packages for Module Referencing

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

The Packages section defines local or remote zip files containing modules. These packages are then referenced using aliases starting with '$'.

```yaml
Packages:
  abc:
    Source: ./package.zip
  def:
    Source: https://example.com/packages/package.zip
```

--------------------------------

### Get Transformed CloudFormation Template

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_cat.md

Use the --transformed flag to retrieve the CloudFormation template after transformations have been applied by CloudFormation. This shows the final template structure.

```bash
rain cat --transformed <stack>
```

--------------------------------

### Deploy CloudFormation Stack

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_deploy.md

Use this command to create or update a CloudFormation stack from a local template file. If no stack name is provided, it defaults to the template filename without the extension. The command will automatically package the template if necessary, creating an S3 bucket for artifacts if one doesn't exist.

```bash
rain deploy <template> [stack]
```

--------------------------------

### Deploy Stack Sets with Delegated Administrator Permissions

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Use this command to deploy a CloudFormation stack set using delegated administrator permissions. Ensure you have the necessary permissions configured.

```bash
rain stackset deploy template.yaml my-stackset \
  --accounts 123456789012 --regions us-east-1 --admin
```

--------------------------------

### Enable Debug Output for Rain Commands

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_info.md

To get detailed debugging information for any rain command, including 'info', use the --debug flag. This is helpful for troubleshooting.

```bash
rain info --debug
```

--------------------------------

### Rain CLI Usage

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

Displays the available commands and their categories for the Rain CLI. Use this to understand the tool's capabilities.

```bash
Usage:
  rain [command]

Stack commands:
  cat         Get the CloudFormation template from a running stack
  cc          Interact with templates using Cloud Control API instead of CloudFormation
  deploy      Deploy a CloudFormation stack or changeset from a local template
  logs        Show the event log for the named stack
  ls          List running CloudFormation stacks or changesets
  rm          Delete a CloudFormation stack or changeset
  stackset    This command manipulates stack sets.
  watch       Display an updating view of a CloudFormation stack

Template commands:
  bootstrap   Creates the artifacts bucket
  build       Create CloudFormation templates
  diff        Compare CloudFormation templates
  fmt         Format CloudFormation templates
  forecast    Predict deployment failures
  merge       Merge two or more CloudFormation templates
  module      Interact with Rain modules in CodeArtifact
  pkg         Package local artifacts into a template
  tree        Find dependencies of Resources and Outputs in a local template

Other Commands:
  console     Login to the AWS console
  help        Help about any command
  info        Show your current configuration
```

--------------------------------

### Describe AWS Lambda Function Resource Type

Source: https://github.com/aws-cloudformation/rain/blob/main/internal/cmd/cc/README.md

Use this AWS CLI command to get the provisioning type for a resource. This helps determine if a resource is fully mutable or immutable.

```sh
sh $ aws cloudformation describe-type --type RESOURCE \
--type-name AWS::Lambda::Function | grep ProvisioningType
```

--------------------------------

### Build Dependency Graph with graph.New

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Constructs a directed acyclic graph of CloudFormation resource dependencies. The graph is ordered by depth, with leaf nodes first. Use this to analyze template structure and dependencies.

```go
package main

import (
    "fmt"

    "github.com/aws-cloudformation/rain/cft/graph"
    "github.com/aws-cloudformation/rain/cft/parse"
)

func main() {
    t, _ := parse.String(`
AWSTemplateFormatVersion: "2010-09-09"
Parameters:
  BucketName:
    Type: String
Resources:
  MyBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Ref BucketName
  MyFunction:
    Type: AWS::Lambda::Function
    Properties:
      Environment:
        Variables:
          BUCKET: !GetAtt MyBucket.Arn
Outputs:
  FunctionArn:
    Value: !GetAtt MyFunction.Arn
`)

    g := graph.New(t)

    // Iterate nodes in dependency order (leaves first)
    for _, node := range g.Nodes() {
        fmt.Printf("Node: %s/%s\n", node.Type, node.Name)
        // Parameters/BucketName
        // Resources/MyBucket
        // Resources/MyFunction
        // Outputs/FunctionArn

        // Get what this node depends on
        deps := g.Get(node)
        for _, dep := range deps {
            fmt.Printf("  -> %s\n", dep)
        }

        // Get what depends on this node (reverse)
        dependents := g.GetReverse(node)
        for _, d := range dependents {
            fmt.Printf("  <- %s\n", d)
        }
    }

    // Print the full graph as a string
    fmt.Println(g.String())

    // Build a custom graph manually
    emptyG := graph.Empty()
    a := graph.Node{Type: "Resources", Name: "BucketA"}
    b := graph.Node{Type: "Resources", Name: "FunctionB"}
    emptyG.Link(b, a) // FunctionB depends on BucketA
    fmt.Println(emptyG.Nodes())
}
```

--------------------------------

### Rain Env Directive Example

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

Illustrates the use of the !Rain::Env directive to read environment variables and insert their values into a CloudFormation template. Ensure the environment variable is exported before deployment.

```yaml
Resources:
  Test:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Rain::Env BUCKET_NAME
```

```yaml
Resources:
  Test:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: abc
```

--------------------------------

### List All Stack Sets

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Lists all available stack sets in your AWS account and region.

```bash
rain stackset ls
```

--------------------------------

### Rain Version Command Help

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_version.md

View help information for the 'rain version' command. This displays available options specific to the version command.

```bash
  -h, --help   help for version
```

--------------------------------

### Watch CloudFormation Stack Status

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Repeatedly displays the current status of a CloudFormation stack. Useful for monitoring deployments triggered outside of Rain. Can wait for the stack to start changing before watching.

```bash
# Watch a stack currently deploying
rain watch my-stack
```

```bash
# Wait for the stack to start changing before watching
rain watch my-stack --wait
```

```bash
rain watch my-stack --profile staging --region ap-southeast-1
```

```bash
# Expected output (refreshes in place):
# my-stack  UPDATE_IN_PROGRESS
#   MyBucket      UPDATE_IN_PROGRESS
#   MyFunction    UPDATE_COMPLETE
```

--------------------------------

### Sample Module Structure

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

A basic structure of a Rain module, including Parameters, Resources, and Outputs. This module defines an S3 bucket.

```yaml
Parameters:
  Name:
    Type: Scalar
Resources:
  Bucket:
    Type: AWS::S3::Bucket
    Metadata:
      OverrideMe: abc
    Properties:
      BucketName: !Ref Name
Outputs:
   BucketArn:
    Value: !GetAtt Bucket.Arn
```

--------------------------------

### Get Raw CloudFormation Template

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_cat.md

Use the --unformatted flag to output the CloudFormation template in its raw, unformatted form. This is useful for inspecting the exact template content without any processing.

```bash
rain cat --unformatted <stack>
```

--------------------------------

### Package Templates with pkg.File and pkg.Template

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Resolves Rain directives and expands modules in CloudFormation templates. Use `pkg.File` for file-based templates and `pkg.Template` for pre-parsed templates. Supports embedded filesystems for assets.

```go
package main

import (
    "embed"
    "fmt"
    "os"

    "github.com/aws-cloudformation/rain/cft/format"
    "github.com/aws-cloudformation/rain/cft/parse"
    "github.com/aws-cloudformation/rain/cft/pkg"
)

func main() {
    // Package a template file (resolves all directives, uploads to S3 if needed)
    packaged, err := pkg.File("template.yaml")
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error packaging: %v\n", err)
        os.Exit(1)
    }
    fmt.Print(format.CftToYaml(packaged))

    // Package with experimental module support
    pkg.Experimental = true
    packaged, err = pkg.File("template-with-modules.yaml")
    if err != nil {
        panic(err)
    }
    fmt.Print(format.CftToYaml(packaged))

    // Package from a pre-parsed *cft.Template with an embedded filesystem
    var fs embed.FS // supply an embedded FS if using embedded assets
    t, _ := parse.File("template.yaml")
    result, err := pkg.Template(t, "./", &fs)
    if err != nil {
        panic(err)
    }
    fmt.Print(format.CftToYaml(result))
}
```

--------------------------------

### Rain Include Directive Example

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

Shows how to use the !Rain::Include directive to parse and insert a YAML or JSON file into a CloudFormation template. The included file's content will be merged into the main template.

```yaml
Resources:
  Test:
    !Rain::Include include-file.yaml
```

```yaml
Type: AWS::S3::Bucket
Properties:
  BucketName: test
```

```yaml
Resources:
  Test:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: test
```

--------------------------------

### Process CloudFormation Stack Events

Source: https://github.com/aws-cloudformation/rain/blob/main/internal/cmd/logs/sample-chart.html

This JavaScript code processes an array of CloudFormation events to determine the start and end times of stack creation or update operations. It then identifies individual resources and their begin and end timestamps.

```javascript
const data = [ { "Id": "ecs-cw-eval", "Type": "AWS::CloudFormation::Stack", "Timestamp": "2023-08-22T17:01:07.030000+00:00", "Status": "CREATE_IN_PROGRESS" }, { "Id": "ecs-cw-eval", "Type": "AWS::CloudFormation::Stack", "Timestamp": "2023-08-22T17:00:59.245000+00:00", "Status": "REVIEW_IN_PROGRESS" } ]; /* const sample = [ { id: "TaskRole", type: "AWS::IAM::Role", begin: "2023-08-22T17:01:09.609000+00:00", end: "2023-08-22T17:01:25.592000+00:00", action: "create" }, { id: "InternetGateway", type: "AWS::EC2::InternetGateway", begin: "2023-08-22T17:01:09.629000+00:00", end: "2023-08-22T17:01:26.253000+00:00", action: "create" } ]; */ // Look for the latest stack action (create/update) and ignore older events let idxOfStart = -1 let idxOfEnd = -1 let stackCreateTs = undefined let stackCompleteTs = undefined for (let i = 0; i < data.length; i++) { const evt = data[i] const ts = new Date(evt.Timestamp) if (evt.Type == "AWS::CloudFormation::Stack") { if (evt.Status === "CREATE_IN_PROGRESS" || evt.Status == "UPDATE_IN_PROGRESS") { if (stackCreateTs === undefined || stackCreateTs < ts) { stackCreateTs = ts idxOfStart = i } } else if (evt.Status === "CREATE_COMPLETE" || evt.Status === "UPDATE_COMPLETE") { if (stackCompleteTs === undefined || stackCompleteTs < ts) { stackCompleteTs = ts idxOfEnd = i } } } } const resources = {} for (let i = idxOfStart; i >= idxOfEnd; i--) { const evt = data[i] if (!resources[evt.Id]) { resources[evt.Id] = {} } const r = resources[evt.Id] r.id = evt.Id r.type = evt.Type const ts = new Date(evt.Timestamp) // Data is sorted descended but we're iterating backwards if (r.begin === undefined) r.begin = ts r.end = ts } const model = [] for (const [k,v] of Object.entries(resources)) { model.push(v) } model.sort((a,b) => {a.begin < b.begin})
```

--------------------------------

### Rain CC Deploy Command Options

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_cc_deploy.md

These are the available options for the rain cc deploy command. The --experimental flag is required to acknowledge the experimental nature of this feature.

```bash
  -c, --config string           YAML or JSON file to set tags and parameters
      --debug                   Output debugging information
  -x, --experimental            Acknowledge that this is an experimental feature
  -h, --help                    help for deploy
      --ignore-unknown-params   Ignore unknown parameters
      --params strings          set parameter values; use the format key1=value1,key2=value2
  -p, --profile string          AWS profile name; read from the AWS CLI configuration file
  -r, --region string           AWS region to use
      --s3-bucket string        Name of the S3 bucket that is used to upload assets
      --s3-prefix string        Prefix to add to objects uploaded to S3 bucket
      --tags strings            add tags to the stack; use the format key1=value1,key2=value2
  -u, --unlock string           Unlock <lockid> and continue
  -y, --yes                     don't ask questions; just deploy
```

--------------------------------

### Check for Drift in Cloud Control Deployment

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Compares the current state of live resources against the state file for a Cloud Control deployment to detect drift.

```bash
rain cc drift --experimental my-deployment
```

--------------------------------

### Output data model

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_pkg.md

Use the --datamodel flag to output the Go YAML data model.

```bash
--datamodel
```

--------------------------------

### Process CloudFormation Stack Events for Waterfall Chart

Source: https://github.com/aws-cloudformation/rain/blob/main/internal/cmd/logs/chart-template.html

This script processes an array of CloudFormation stack events to identify the start and end times of stack operations. It then iterates through resources, calculates their individual timings relative to the total stack duration, and prepares data for rendering a waterfall chart. Ensure the `__DATA__` variable is populated with actual stack event data.

```javascript
const data = __DATA__ // Look for the latest stack action (create/update) and ignore older events let idxOfStart = -1 let idxOfEnd = -1 let stackCreateTs = undefined let stackCompleteTs = undefined var stackName = "[Stack Name]" for (let i = 0; i < data.length; i++) { const evt = data[i] const ts = new Date(evt.Timestamp) if (evt.Type == "AWS::CloudFormation::Stack") { if (evt.Status === "CREATE_IN_PROGRESS" || evt.Status == "UPDATE_IN_PROGRESS") { stackName = evt.Id if (stackCreateTs === undefined || stackCreateTs < ts) { stackCreateTs = ts idxOfStart = i } } else if (evt.Status === "CREATE_COMPLETE" || evt.Status === "UPDATE_COMPLETE") { if (stackCompleteTs === undefined || stackCompleteTs < ts) { stackCompleteTs = ts idxOfEnd = i } } } } const resources = {} for (let i = idxOfStart; i >= idxOfEnd; i--) { const evt = data[i] if (!resources[evt.Id]) { resources[evt.Id] = {} } const r = resources[evt.Id] r.id = evt.Id r.type = evt.Type const ts = new Date(evt.Timestamp) // Data is sorted descended but we're iterating backwards if (r.begin === undefined) r.begin = ts r.end = ts } const model = [] for (const [k,v] of Object.entries(resources)) { model.push(v) } model.sort((a,b) => {a.begin < b.begin})
```

--------------------------------

### Retrieve CloudFormation Stack Config File

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_cat.md

Use the --config flag to download the configuration file used to deploy the stack instead of the template. This is useful for understanding the deployment parameters.

```bash
rain cat --config <stack>
```

--------------------------------

### Deploy CloudFormation Stack Set

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Creates or updates a CloudFormation stack set and its instances across multiple accounts and regions. Can deploy using a config file with full StackSet options. Can update without prompting.

```bash
# Deploy a stack set to specific accounts and regions
rain stackset deploy template.yaml my-stackset \
  --accounts 123456789012,234567890123 \
  --regions us-east-1,eu-west-1
```

```yaml
Parameters:
  Env: prod
Tags:
  Team: platform
StackSet:
  description: "Platform infrastructure stack set"
StackSetInstances:
  accounts:
    - "123456789012"
  regions:
    - us-east-1
    - us-west-2
```

```bash
rain stackset deploy template.yaml my-stackset --config stackset-config.yaml
```

```bash
# Update without prompting
rain stackset deploy template.yaml my-stackset --yes
```

--------------------------------

### Module with ForEach Loop

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

Use `ForEach` to iterate over a list parameter and create multiple instances of a module. The `Properties` are dynamically set using `!Sub` with `$MapValue` to include the list item.

```yaml
Parameters:
  List:
    Type: CommaDelimitedList
    Default: A,B,C

Modules:
  Content:
    Source: ./map-module.yaml
    ForEach: !Ref List
    Properties:
      Name: !Sub my-bucket-$MapValue
```

--------------------------------

### Check Command Help

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_check.md

Displays help information for the 'check' command.

```bash
rain check --help
```

--------------------------------

### Download Template State File

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_cc_state.md

Use this command to download the state file for a template deployed with cc deploy. The state file is stored in the rain assets bucket.

```bash
rain cc state <name>
```

--------------------------------

### Show Details of a Specific Stack Set

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Retrieves and displays detailed information about a particular stack set.

```bash
rain stackset ls my-stackset
```

--------------------------------

### Deploy CloudFormation Stack with Rain

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Use 'rain deploy' to create or update CloudFormation stacks. It handles asset packaging, parameter prompting, change-set previews, and streams events. Supports explicit stack names, parameters, tags, config files, environment variable defaults, no-exec changesets, role assumption, and detachment.

```bash
# Basic deploy (stack name defaults to filename without extension)
rain deploy infrastructure.yaml
```

```bash
# Deploy with explicit stack name, parameters, and tags
rain deploy infrastructure.yaml my-stack \
  --params Env=prod,BucketName=my-bucket \
  --tags Team=platform,CostCenter=123
```

```bash
# Deploy using a config file (CodePipeline template-configuration format)
cat > config.yaml <<'EOF'
Parameters:
  Env: prod
  BucketName: my-bucket
Tags:
  Team: platform
EOF
rain deploy infrastructure.yaml my-stack --config config.yaml
```

```bash
# Deploy with environment-variable defaults (no prompts)
export RAIN_VAR_Env=prod
export RAIN_DEFAULT_TAG_Team=platform
rain deploy infrastructure.yaml my-stack --yes
```

```bash
# Create a changeset without executing it
rain deploy --no-exec infrastructure.yaml my-stack my-changeset
```

```bash
# Execute a previously created changeset
rain deploy --changeset my-stack my-changeset
```

```bash
# Keep resources on failure (disable rollback) and assume an IAM role
rain deploy infrastructure.yaml my-stack \
  --keep \
  --role-arn arn:aws:iam::123456789012:role/CfnDeployRole
```

```bash
# Detach after starting (fire-and-forget)
rain deploy infrastructure.yaml my-stack --detach
```

```bash
# Expected output:
# Previewing changes for my-stack...
# [+] AWS::S3::Bucket  MyBucket
# Deploy? (y/N) y
# my-stack CREATE_IN_PROGRESS
# my-stack CREATE_COMPLETE
```

--------------------------------

### Visualize CloudFormation Template Dependencies

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Finds and displays dependencies between Parameters, Resources, and Outputs in a local template. Can show all elements, including those without dependencies, or show both dependencies and dependents for each element. Can output graph in GraphViz DOT format.

```bash
# Show dependency tree (elements with dependencies)
rain tree template.yaml
```

```bash
# Show all elements, including those without dependencies
rain tree template.yaml --all
```

```bash
# Show both dependencies and dependents for each element
rain tree template.yaml --both
```

```bash
# Output graph in GraphViz DOT format (for rendering with graphviz)
rain tree template.yaml --dot | dot -Tpng -o deps.png
```

```bash
# Example output:
# Resources/MyFunction:
# - Parameters/MemorySize
# - Resources/MyBucket
# Resources/MyBucket:
# (no dependencies)
```

--------------------------------

### Download Cloud Control Deployment State File

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Retrieves and downloads the state file associated with a Cloud Control API deployment.

```bash
rain cc state --experimental my-deployment
```

--------------------------------

### Deploy Resources with Rain CC

Source: https://github.com/aws-cloudformation/rain/blob/main/internal/cmd/cc/README.md

Command to deploy CloudFormation resources using the experimental 'rain cc deploy' command. The '-x' flag indicates experimental status and requires user acknowledgment.

```sh
$ rain cc deploy -x my-template.yaml my-deployment-name
```

--------------------------------

### S3 Upload with Lambda Code Options

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

Upload Lambda function code using `!Rain::S3` with options for path, zipping, bucket/key properties, and a pre-upload build script.

```yaml
Resources:
  MyFunction:
    Type: AWS::Lambda::Function
    Properties:
      Code: !Rain::S3 
        Path: lambda-dist
        Zip: true
        BucketProperty: S3Bucket
        KeyProperty: S3Key
        Run: buildscript.sh
```

--------------------------------

### Generate CloudFormation Skeletons with Rain Build

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Use `rain build` to generate CloudFormation template skeletons from resource type schemas. Options include generating minimal templates, outputting as JSON, listing available types, using AI for prompts, or generating compliance rules.

```bash
rain build AWS::S3::Bucket
```

```bash
rain build AWS::S3::Bucket --bare
```

```bash
rain build AWS::S3::Bucket --json
```

```bash
rain build --list AWS::S3
```

```bash
rain build --prompt "A VPC with 2 private subnets and a NAT gateway"
```

```bash
rain build --prompt "S3 bucket must have versioning enabled" --prompt-lang guard
```

```bash
rain build --recommend
```

```bash
rain build --schema AWS::Lambda::Function
```

```bash
rain build --pkl-class AWS::DynamoDB::Table
```

--------------------------------

### Enable Experimental Features

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_rm.md

Use the '--experimental' flag to enable experimental features for the 'rm' command. This flag requires explicit acknowledgment of potential risks associated with experimental functionality.

```bash
rain rm <stack> --experimental
```

--------------------------------

### rain cc state Command Options

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_cc_state.md

These are the available options for the rain cc state command. Use --debug for verbose output, -x or --experimental to acknowledge experimental features, -h or --help for assistance, -p or --profile to specify an AWS profile, -r or --region to set the AWS region, and --s3-bucket or --s3-prefix to configure S3 upload details.

```bash
      --debug              Output debugging information
```

```bash
  -x, --experimental       Acknowledge that this is an experimental feature
```

```bash
  -h, --help               help for state
```

```bash
  -p, --profile string     AWS profile name; read from the AWS CLI configuration file
```

```bash
  -r, --region string      AWS region to use
```

```bash
      --s3-bucket string   Name of the S3 bucket that is used to upload assets
```

```bash
      --s3-prefix string   Prefix to add to objects uploaded to S3 bucket
```

--------------------------------

### Open CloudFormation Console

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Opens the AWS CloudFormation console in the default web browser using federated sign-in.

```bash
rain console
```

--------------------------------

### Bootstrap Rain Artifacts S3 Bucket

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Creates the S3 bucket required for `rain deploy` and `rain pkg` to store uploaded assets. This command prompts for confirmation by default.

```bash
rain bootstrap
```

--------------------------------

### Run Rain Forecast Command

Source: https://github.com/aws-cloudformation/rain/blob/main/internal/cmd/forecast/README.md

Execute the rain forecast command with the experimental flag enabled. Supply the template file and stack name as arguments.

```sh
rain forecast -x my-template.yaml my-stack-name 
```

--------------------------------

### Output debugging information

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_pkg.md

Use the --debug flag to enable the output of debugging information.

```bash
--debug
```

--------------------------------

### Rain Tree Command Synopsis

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_tree.md

Use this command to find and display dependencies within a local CloudFormation template. Specify the template file path as an argument.

```bash
rain tree [template]
```

--------------------------------

### Run Rain Forecast Command

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_forecast.md

Basic usage of the rain forecast command. Add --experimental or -x to use this experimental feature. Replace <template> with your CloudFormation template file and [stackName] with the desired stack name.

```bash
rain forecast --experimental <template> [stackName]
```

--------------------------------

### Compare CloudFormation Templates or Maps

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Utilize `diff.New` to compare two `*cft.Template` objects and `diff.CompareMaps` for raw `map[string]interface{}`. The `Diff` object provides methods to determine changes and format them, while `GetResourceActions` helps identify create, update, or delete operations.

```go
package main

import (
    "fmt"

    "github.com/aws-cloudformation/rain/cft/diff"
    "github.com/aws-cloudformation/rain/cft/parse"
)

func main() {
    a, _ := parse.String(`
AWSTemplateFormatVersion: "2010-09-09"
Resources:
  MyBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: old-name
`)
    b, _ := parse.String(`
AWSTemplateFormatVersion: "2010-09-09"
Resources:
  MyBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: new-name
  NewQueue:
    Type: AWS::SQS::Queue
`)

    d := diff.New(a, b)

    // Check overall diff mode
    fmt.Println("Mode:", d.Mode()) // (|) Involved

    // Print short diff (only changed elements)
    fmt.Println(d.Format(false))

    // Print long diff (include unchanged)
    fmt.Println(d.Format(true))

    // Get per-resource actions (Create/Update/Delete/None)
    actions := diff.GetResourceActions(d)
    for resource, action := range actions {
        fmt.Printf("%s: %s\n", resource, action)
        // MyBucket: Update
        // NewQueue: Create
    }

    // Compare raw maps directly
    mapA := map[string]interface{}{"key": "old"}
    mapB := map[string]interface{}{"key": "new", "extra": true}
    mapDiff := diff.CompareMaps(mapA, mapB)
    fmt.Println(mapDiff.Mode()) // (|) Involved
}
```

--------------------------------

### Open Console with Specific Stack Pre-selected

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Opens the AWS console with a particular CloudFormation stack already selected.

```bash
rain console my-stack
```

--------------------------------

### Format CloudFormation Templates with Rain

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Use `rain fmt` to format CloudFormation templates in place, convert them to JSON or Pkl, verify formatting, or process from stdin. Options include keeping original property ordering or removing CDK metadata.

```bash
rain fmt template.yaml --write
```

```bash
rain fmt template.yaml --json
```

```bash
rain fmt template.yaml --pkl
```

```bash
rain fmt template.yaml --verify && echo "OK"
```

```bash
cat template.yaml | rain fmt
```

```bash
rain fmt template.yaml --unsorted
```

```bash
rain fmt cdk-output.yaml --uncdk
```

--------------------------------

### List CloudFormation Stack Sets

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_stackset_ls.md

Use this command to list CloudFormation stack sets in a specific region. If a stack set name is provided, it will show all stack instances and the last 10 operations.

```bash
rain stackset ls <stack set>
```

--------------------------------

### Generate Gantt Chart for Stack Operations

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

Use the 'rain log --chart' command to output a Gantt chart of stack operation timings to an HTML file for visualization in a browser.

```bash
rain log --chart CDKToolkit > ~/Desktop/chart.html
```

--------------------------------

### Specify S3 bucket

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_pkg.md

Use the --s3-bucket flag to specify the name of the S3 bucket used for uploading assets.

```bash
--s3-bucket string
```

--------------------------------

### Import Built-in Modules in CloudFormation

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Demonstrates importing multiple built-in Rain modules within a parent CloudFormation template. This allows for reusable infrastructure components like VPCs, S3 buckets, and Lambda functions.

```yaml
# Example parent template importing multiple built-in modules
AWSTemplateFormatVersion: "2010-09-09"

Modules:

  # Simple VPC with 2 public + 2 private subnets and NAT gateways
  Network:
    Source: ./modules/simple-vpc.yaml

  # S3 bucket with AES256 encryption and all public access blocked
  DataBucket:
    Source: ./modules/encrypted-bucket.yaml

  # Compliant bucket with access logs, replication, and TLS-enforcing policy
  AuditBucket:
    Source: ./modules/compliant-bucket.yaml

  # Cognito User Pool + Identity Pool
  Auth:
    Source: ./modules/cognito.yaml

  # API Gateway REST API
  Api:
    Source: ./modules/rest-api.yaml

  # Lambda function + API Gateway resources for an API endpoint
  ApiHandler:
    Source: ./modules/api-resource.yaml
    Properties:
      ApiId: !GetAtt Api.RestApiId

  # S3 static website + CloudFront distribution
  StaticSite:
    Source: ./modules/static-site.yaml

  # ELBv2 load balancer
  LoadBalancer:
    Source: ./modules/load-balancer.yaml

  # DynamoDB table (simple-table)
  Table:
    Source: ./modules/simple-table.yaml

Outputs:
  VpcId:
    Value: !GetAtt Network.VpcId
  BucketName:
    Value: !GetAtt DataBucket.BucketName

```

--------------------------------

### Include YAML/JSON file as object

Source: https://github.com/aws-cloudformation/rain/blob/main/docs/rain_pkg.md

Use the !Rain::Include directive to read a local YAML or JSON file and insert its content as an object into the template.

```yaml
!Rain::Include <path>
```

--------------------------------

### Generated Resources from ForEach Module

Source: https://github.com/aws-cloudformation/rain/blob/main/README.md

This shows the expanded CloudFormation resources generated by the module with the `ForEach` loop. Each resource is uniquely named based on the module name and index (e.g., `Content0Bucket`).

```yaml
Parameters:
  List:
    Type: CommaDelimitedList  
    Default: A,B,C
Resources:
  Content0Bucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: my-bucket-A
  Content1Bucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: my-bucket-B
  Content2Bucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: my-bucket-C
```

--------------------------------

### Predict CloudFormation Deployment Failures

Source: https://context7.com/aws-cloudformation/rain/llms.txt

Analyzes a template against the target AWS account to predict deployment failures before they happen. Can check for missing permissions, pre-existing conflicting resources, and resource-specific constraints. Can supply parameters for accurate checks and include IAM permission checks.

```bash
# Run all checks for all stack actions
rain forecast --experimental template.yaml
```

```bash
# Run with a specific stack name for update/delete checks
rain forecast --experimental template.yaml my-existing-stack
```

```bash
# Only check for create failures
rain forecast --experimental template.yaml --action create
```

```bash
# Show all checks, not just failures
rain forecast --experimental template.yaml --all
```

```bash
# Supply parameters for accurate checks
rain forecast --experimental template.yaml \
  --params BucketName=my-bucket,Env=prod
```

```bash
# Include IAM permission checks (can be slow)
rain forecast --experimental template.yaml --include-iam
```

```bash
# Ignore specific resource types or check codes
rain forecast --experimental template.yaml \
  --ignore AWS::S3::Bucket,F0002
```

```bash
# Use a forecast plugin (.so shared library)
rain forecast --experimental template.yaml \
  --plugin ./my-forecast-plugin.so
```

```bash
# Expected output:
# F0001 (FAIL) AWS::S3::Bucket MyBucket: Bucket 'my-bucket' already exists
# F0012 (PASS) AWS::Lambda::Function MyFunction: IAM role exists
```