Metadata-Version: 2.1
Name: sceptre
Version: 2.0.0rc2
Summary: Cloud Provisioning Tool
Home-page: https://github.com/cloudreach/sceptre
Author: Cloudreach
Author-email: sceptre@cloudreach.com
License: Apache2
Keywords: sceptre
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Natural Language :: English
Classifier: Environment :: Console
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Description-Content-Type: text/markdown
Requires-Dist: boto3 (<2.0,>=1.3)
Requires-Dist: click (==6.7)
Requires-Dist: PyYaml (==3.13)
Requires-Dist: Jinja2 (<3,>=2.8)
Requires-Dist: packaging (==16.8)
Requires-Dist: colorama (==0.3.7)
Requires-Dist: six (==1.11.0)
Requires-Dist: networkx (==2.1)
Provides-Extra: test
Requires-Dist: pytest (>=3.2) ; extra == 'test'
Requires-Dist: troposphere (>=2.0.0) ; extra == 'test'
Requires-Dist: moto (==0.4.31) ; extra == 'test'
Requires-Dist: mock (==2.0.0) ; extra == 'test'
Requires-Dist: behave (==1.2.5) ; extra == 'test'
Requires-Dist: freezegun (==0.3.9) ; extra == 'test'

# Sceptre

![image](https://circleci.com/gh/cloudreach/sceptre.png?style=shield) ![image](https://badge.fury.io/py/sceptre.svg)

# About

Sceptre is a tool to drive [AWS CloudFormation](https://aws.amazon.com/cloudformation).
It automates the mundane, repetitive and error-prone tasks, enabling you to concentrate
on building better infrastructure.

# Features

- Code reuse by separating a Stack's template and its configuration
- Support for templates written in JSON, YAML, Jinja2 or Python DSLs such as Troposphere
- Dependency resolution by passing of Stack outputs to parameters of dependent Stacks
- Stack Group support by bundling related Stacks into logical groups (e.g. dev and prod)
- Stack Group-level commands, such as creating multiple Stacks with a single command
- Fast, highly parallelised builds
- Built in support for working with Stacks in multiple AWS accounts and regions
- Infrastructure visibility with meta-operations such as Stack querying protection
- Support for inserting dynamic values in templates via customisable Resolvers
- Support for running arbitrary code as Hooks before/after Stack builds

# Benefits

- Utilises cloud-native Infrastructure as Code engines (CloudFormation)
- You do not need to manage state
- Simple templates using popular templating syntax - Yaml & Jinja
- Powerful flexibility using a mature programming language - Python
- Easy to integrate as part of a CI/CD pipeline by using Hooks
- Simple CLI and API
- Unopinionated - Sceptre does not force a specific project structure

# Install

`$ pip install sceptre`

More information on installing sceptre can be found in our [Installation Guide](https://sceptre.cloudreach.com/latest/docs/install.html)

# Migrate v1 to v2

We have tried to make the migration to Sceptre v2 as simple as possible. For
information about how to migration your v1 project please see our [Migration
Guide](https://github.com/cloudreach/sceptre/wiki/Migration-Guide:-V1-to-V2)

# Example

Sceptre organises Stacks into "Stack Groups". Each Stack is represented by a
YAML configuration file stored in a directory which represents the Stack Group.
Here, we have two Stacks, `vpc` and `subnets`, in a Stack Group named `dev`:

```bash
$ tree
.
├── config
│   └── dev
│        ├── config.yaml
│        ├── subnets.yaml
│        └── vpc.yaml
└── templates
    ├── subnets.py
    └── vpc.py
```

We can create a Stack with the `create` command. This `vpc` Stack contains
a VPC.

```bash
$ sceptre create dev/vpc.yaml

dev/vpc - Creating stack dev/vpc
VirtualPrivateCloud AWS::EC2::VPC CREATE_IN_PROGRESS
dev/vpc VirtualPrivateCloud AWS::EC2::VPC CREATE_COMPLETE
dev/vpc sceptre-demo-dev-vpc AWS::CloudFormation::Stack CREATE_COMPLETE
```

The `subnets` Stack contains a subnet which must be created in the VPC. To do
this, we need to pass the VPC ID, which is exposed as a Stack output of the
`vpc` Stack, to a parameter of the `subnets` Stack. Sceptre automatically
resolves this dependency for us.

```bash
$ sceptre create dev/subnets.yaml
dev/subnets - Creating stack
dev/subnets Subnet AWS::EC2::Subnet CREATE_IN_PROGRESS
dev/subnets Subnet AWS::EC2::Subnet CREATE_COMPLETE
dev/subnets sceptre-demo-dev-subnets AWS::CloudFormation::Stack CREATE_COMPLETE
```

Sceptre implements meta-operations, which allow us to find out information
about our Stacks:

```bash
$ sceptre list resources dev/subnets.yaml

- LogicalResourceId: Subnet
  PhysicalResourceId: subnet-445e6e32
  dev/vpc:
- LogicalResourceId: VirtualPrivateCloud
  PhysicalResourceId: vpc-c4715da0
```

Sceptre provides Stack Group level commands. This one deletes the whole `dev`
Stack Group. The subnet exists within the vpc, so it must be deleted first.
Sceptre handles this automatically:

```bash
$ sceptre delete dev

Deleting stack
dev/subnets Subnet AWS::EC2::Subnet DELETE_IN_PROGRESS
dev/subnets - Stack deleted
dev/vpc Deleting stack
dev/vpc VirtualPrivateCloud AWS::EC2::VPC DELETE_IN_PROGRESS
dev/vpc - Stack deleted
```

> Note: Deleting Stacks will _only_ delete a given Stack, or the Stacks that
> are directly in a given StackGroup. By default Stack dependencies that are
> external to the StackGroup are not deleted.

Sceptre can also handle cross Stack Group dependencies, take the following
example project:

```bash
$ tree
.
├── config
│   ├── dev
│   │   ├── network
│   │   │   └── vpc.yaml
│   │   ├── users
│   │   │   └── iam.yaml
│   │   ├── compute
│   │   │   └── ec2.yaml
│   │   └── config.yaml
│   └── staging
│       └── eu
│           ├── config.yaml
│           └── stack.yaml
├── hooks
│   └── stack.py
├── templates
│   ├── network.json
│   ├── iam.json
│   ├── ec2.json
│   └── stack.json
└── vars
    ├── dev.yaml
    └── staging.yaml
```

In this project `staging/eu/stack.yaml` has a dependency on the output of
`dev/users/iam.yaml`. If you wanted to create the Stack
`staging/eu/stack.yaml`, Sceptre will resolve all of it's dependencies,
including `dev/users/iam.yaml`, before attempting to create the Stack.

## Usage

Sceptre can be used from the CLI, or imported as a Python package.

## CLI

```bash
Usage: sceptre [OPTIONS] COMMAND [ARGS]...

Sceptre is a tool to manage your cloud native infrastructure deployments.
Options:
 --version Show the version and exit.
 --debug Turn on debug logging.
 --dir TEXT Specify sceptre directory.
 --output [yaml|json] The formatting style for command output.
 --no-colour Turn off output colouring.
 --var TEXT A variable to template into config files.
 --var-file FILENAME A YAML file of variables to template into config
 files.
 --help Show this message and exit.

Commands:
create Creates a Stack or a change set.
delete Deletes a Stack or a change set.
describe Commands for describing attributes of Stacks.
estimate-cost Estimates the cost of the template.
execute Executes a change set.
generate Prints the template.
init Commands for initialising Sceptre projects.
launch Launch a Stack or Stack_group.
list Commands for listing attributes of Stacks.
set-policy Sets Stack policy.
status Print status of Stack or Stack group.
update Update a Stack.
validate Validates the template.
```

## Python

Using Sceptre as a Python module is very straightforward. You need to create
a SceptreContext, which tells Sceptre where your project path is and which path
you want to execute on, we call this the "command path".

After you have created a SceptreContext you need to pass this into
a SceptrePlan. On instantiation the SceptrePlan will handle all the required
steps to make sure the action you wish to take on the command path are
resolved.

After you have instantiated a SceptrePlan you can access all the actions you
can take on a Stack, such as `validate()`, `launch()`, `list()` and `delete()`.

```python
from sceptre.context import SceptreContext
from sceptre.plan.plan import SceptrePlan

context = SceptreContext("/path/to/project", "command_path")
plan = SceptrePlan(context)
plan.launch()
```

Full API reference documentation can be found in the [Documentation](https://sceptre.cloudreach.com/latest/docs/index.html)

## Tutorial and Documentation

- [Get Started](https://sceptre.cloudreach.com/latest/docs/get_started.html)
- [Documentation](https://sceptre.cloudreach.com/latest/docs/index.html)

## Contributing

See our (Contributing Guide)[CONTRIBUTING.md]


