DOCSEARCHbyAlgolia
Submit Docs

Runiac Documentation

website·Indexed 32 days ago

https://runiac.io/

Runiac is an Infrastructure as Code (IaC) framework designed to simplify cloud adoption and multi-region deployments. It supports various tools including Terraform, ARM Templates, Azure Bicep, Terragrunt, AWS CDK, CloudFormation, and Pulumi, providing features for ephemeral environments, execution patterns, and persisting CLI & SDK state via Docker.

Tokens
6.1K
Snippets
33
Records
56
Agent score
65%

What's inside Runiac

  1. Runiac Core Features for IaC Development

    Runiac provides several advanced features to increase productivity in cloud infrastructure development:

    • Ephemeral Environments: Quickly spin up and down cloud environments for testing from local machines or automatically from pull requests.
    • Docker Integration: Every project is baked into a Docker container to ensure portability and consistency across different environments.
    • Multi-Region Deployments: Deploy to multiple regions while keeping the codebase DRY (Don't Repeat Yourself) and avoiding complex loops.
    • Pluggable Runners: Support for various IaC tools via a runner-based architecture.
    • Declarative Orchestration: Execution logic is handled by Runiac, reducing the need for complex pipeline scripts.

  2. Runiac Core Features for IaC Development

    Runiac provides several advanced features to increase productivity in cloud infrastructure development:

    • Ephemeral Environments: Quickly spin up and down cloud environments for testing from local machines or automatically via pull requests in CI.
    • Docker Integration: Every project is packaged into a Docker container to ensure portability and consistency across different environments.
    • Multi-Region Deployments: Deploy to multiple regions while keeping the codebase DRY (Don't Repeat Yourself) and avoiding complex loops.
    • Pluggable Runners: Support for various IaC tools through a runner-based architecture.
    • Declarative Orchestration: Execution logic is handled by Runiac, reducing the need for complex pipeline scripts.

  3. Supported Infrastructure as Code (IaC) tools for Runiac

    Runiac supports a wide range of Infrastructure as Code (IaC) tools, allowing users to extend or customize their infrastructure while reusing existing workflows. Supported tools include:

    • Terraform
    • Terragrunt
    • Azure Bicep
    • ARM Templates
    • AWS CDK
    • CloudFormation
    • Pulumi

  4. Understand runiac track execution and dependencies

    In runiac, all tracks (except for the pre-track) are executed in parallel. Tracks are designed to be independent and must not have dependencies on each other. If multiple steps require a specific order of execution, they should be grouped together as a single track with multiple steps. For a track to be executed, it must contain at least one defined Step.

  5. Create standalone pages using Markdown

    Standalone pages can be written using Markdown without the need for React, allowing for the creation of simple, static content pages.

  6. Install runiac manually via pre-compiled binaries

    If Homebrew is not available, you can install runiac by downloading the pre-compiled binaries from the GitHub releases page and copying the executable to a directory in your system's PATH.

  7. Install runiac using Homebrew

    Install the runiac CLI on macOS or Linux using the official Optum Homebrew tap.
    brew install optum/tap/runiac

  8. Implement functional validation for IaC deployments

    To ensure infrastructure is correctly supporting the application, use one or both of the following testing strategies:

    1. Application-Level Post-Deployment Tests: Trigger tests immediately after deployment that target a health check endpoint or a vital business function to ensure the infrastructure is operational.
    2. Synthetic Monitoring: Implement synthetic tests running on a regular cadence to continuously verify that vital business functions are available and the system maintains uptime.

  9. Implement functional testing for declarative Infrastructure as Code (IaC)

    When using declarative IaC tools like Terraform, basic post-deployment tests that only verify if a resource exists or if a parameter is set to a specific value provide little value because the tool itself handles the state declaration. Instead, focus testing efforts on 'Vital Business Functions' of the system to ensure the infrastructure actually supports the application's requirements.

    There are two primary strategies for implementing this:

    1. Application-Level Post-Deployment Tests: Trigger tests immediately after deployment that verify a health check endpoint or a critical business function.
    2. Synthetic Monitoring: Run tests on a continuous cadence to verify that the system remains operational and that vital business functions are consistently available.

  10. Configure container startup and shutdown via entrypoint.sh

    Runiac requires an entrypoint.sh script to be present in the container to handle configuration during startup and shutdown. The Runiac container executes this script as the Docker Entrypoint. This is commonly used to retrieve centralized configurations or secrets required for the deployment.

  11. Shift IaC testing focus from configuration to business functions

    When using declarative IaC tools like Terraform, basic post-deployment tests that verify if a resource exists or if a parameter is set to a specific value provide little value because the tool itself handles the declarative state. Instead, testing should focus on functionally verifying the business functions of the system. This validation logic is often more effective when centralized as a separate function that can be triggered across multiple use cases rather than being tightly coupled to the IaC deployment process.

  12. Verify IaC deployments using application-level tests and synthetic monitoring

    To ensure infrastructure deployments support business requirements, use a combination of the following two testing strategies:

    1. Post-Deployment Application Tests: Trigger tests immediately after deployment that target application-level functionality, such as calling a health check endpoint or executing a vital business function.
    2. Synthetic Monitoring: Implement continuous synthetic tests running on a regular cadence to verify that vital business functions remain operational and the system maintains uptime.