Components

Low-touch Deployments

Perform all deployment logic from within your application environment, removing complex automation and high privileges from your central build platform.
Components

Iterate faster

Deploy directly to your Cloud environment without performing the deployment logic from your workstation. Attini is up to 5x times faster than competing tools.
Components

Manage any technologies

Attini can manage any technology you use for your Cloud deployment. So you can adopt new technologies and integrate them with your legacy.

Use the Cloud to manage the Cloud

The cloud is often hard to manage. You have multiple apps in multiple environments managed by multiple tools. Having an overview and staying compliant while evolving your IT landscape is often overwhelming.

But why is it so hard? You have your code, and the cloud has the infrastructure to deploy it. Using only cloud resources, Attini will package and deploy your code while keeping track of what’s deployed where.

IaC is not the complete solution

Infrastructures as Code (IaC) make it easy to define and reproduce Cloud resources. But we usually find that simply creating the resource is not enough. We often need to extend it with custom logic, automatic tests or lookups. We also need to know what version of the code we run in different environments, manage dependencies and perform rollbacks when things go wrong.

AppDeploymentPlan:
  Type: Attini::Deploy::DeploymentPlan
  Properties:
    DeploymentPlan:
      - Name: Database
        Type: AttiniCfn
        Properties:
          StackName: !Sub ${Env}-database
          Template: /database.yaml
      - Name: API
        Type: AttiniSam
        Properties:
          StackName: !Sub ${Env}-api-app
          Project:
            Path: /api-app
          Parameters:
            DatabaseARN.$:
              $.output.Database.DatabaseARN

let database = new AttiniCfn(this, 'Database', {
  template: '/database.yaml',
  stackName: env.valueAsString + '-database'
});

let api = new AttiniSam(this, 'API', {
  project: {
    path: '/api-app'
  },
  parameters: {
    DatabaseARN: JsonPath.stringAt(database.getOutputPath('DatabaseARN'))
  },
  stackName: env.valueAsString + '-api-app'
});

new DeploymentPlan(this, 'AppDeploymentPlan', {
  definition: database.next(api)
});

let database = new AttiniCfn(this, 'Database', {
  template: '/database.yaml',
  stackName: env.valueAsString + '-database'
});

let api = new AttiniSam(this, 'API', {
  project: {
    path: '/api-app'
  },
  parameters: {
    DatabaseARN: JsonPath.stringAt(database.getOutputPath('DatabaseARN'))
  },
  stackName: env.valueAsString + '-api-app'
});

new DeploymentPlan(this, 'AppDeploymentPlan', {
  definition: database.next(api)
});

database = AttiniCfn(self, "Database",
  stack_name = env.value_as_string + "-database",
  template = "/database.yaml"
)

api = AttiniSam(self, "API",
  stack_name = env.value_as_string + '-api-app',
  project = {
    "path": "/api-app"
  },
  parameters = {
    "DatabaseARN": database.get_output_path('DatabaseARN')
  }
)

deployment_plan = DeploymentPlan(self, "DeploymentPlan",
  definition = database.next(api)
)

AttiniCfn database =
        new AttiniCfn(this, "Database",
                      AttiniCfnProps.builder()
                                    .stackName(environment + "-database")
                                    .template("/database.yaml")
                                    .build());

Map<String, String> apiParameters =
        Map.of("DatabaseARN",
              JsonPath.stringAt(database.getOutputPath("DatabaseARN")));

AttiniSam api =
        new AttiniSam(this, "API",
                      AttiniSamProps.builder()
                                    .project(Project.builder().path("/api-app").build())
                                    .stackName(environment + "-api-app")
                                    .parameters(apiParameters)
                                    .build());

new DeploymentPlan(this,
                  "AppDeploymentPlan",
                  DeploymentPlanProps.builder()
                                      .definition(database.next(api))
                                      .build());

Define a Deployment Plan

With the Attini Deployment Plan you get a flexible, serverless, and fast pipeline that can integrate with anything in your Cloud environment.

The Attini types make it easy to deploy and configure any technology you need.

Use conditions, parallel execution and manual approvals to design any type of workflow. Learn more about how to perform different tasks by reading our guides.

Write your deployment plan in a CloudFormation template or your favorite programming language using the AWS CDK together with the Attini Constructs.

feature image

Package a Distribution

Package your code, configuration and Deployment Plan into a versioned Distribution. Make your deployment logic a part of the artifact.

feature image

Deploy everywhere

Deploy the Distribution to your different environments, either from your local workstation or your CI/CD platform. All deployment logic is performed from inside your AWS account.

feature image

Manage environments

With Attini it’s easy to get an environment overview and compare different environments with each other. Attini keeps track of your deployment history and saves copies of old Distributions within each environment, making rollbacks simple.

Get started with Attini!

Attini is free and no registration is required. The only thing you need is an AWS Account.

Get started now

Introduction

ƒ