Terracognita is an opensource project lead by Cycloid that allows you to import your current Cloud infrastructure to an Infrastructure As Code Terraform configuration (HCL) or/and to a Terraform State.

At Cycloid, Infrastructure As Code is in the company DNA since the beginning. To help our new customers adopting this best practice, we decided to build Terracognita to convert an existing infrastructure on AWS into Terraform code in an automated way, relying on Terraform providers built by the community. We focused on AWS for a first release, but Azure, GCP, Alibaba, Vmware and Openstack will be the next to be integrated.

We decided to opensource this tool as we believe that it will help people to adopt IaC in an easy way. Cycloid provides this tool to let people import their infrastructure into Cycloid's pipelines, allow them to generate infrastructure diagram and manage all infra/application lifecycle from a single interface.

Find more information on our Github.

# Cloud providers

Terracognita currently imports AWS, GCP and AzureRM cloud provider as terraform (0.12.8) resource/state. Please see the following versions as follow:

Providers:

  • AWS: 2.31.0
  • AzureRM: 1.35.0
  • GCP: 2.16.0

# Installation

# Binary

Visit the releases page to select your system, architecture and version you need. Then:

$ curl -L https://github.com/cycloidio/terracognita/releases/download/v0.4.0/terracognita-linux-amd64.tar.gz -o terracognita-linux-amd64.tar.gz
$ tar -xf terracognita-linux-amd64.tar.gz
$ chmod u+x terracognita-linux-amd64
$ sudo mv terracognita-linux-amd64 /usr/local/bin/terracognita
1
2
3
4

# Development

You can build and install with the latest sources, you will enjoy the new features and bugfixes. It uses Go Modules, so GO 1.11+ is required.

$ git clone https://github.com/cycloidio/terracognita
$ cd terracognita
$ make install
1
2
3

# Arch Linux

There are two entries in the AUR: terracognita-git (targets the latest git commit) and terracognita (targets the latest stable release).

$ yay -Ss terracognita
aur/terracognita 1:0.4.0-1 (+0 0.00%) 
    Reads from existing Cloud Providers (reverse Terraform) and generates your infrastructure as code on Terraform configuration
aur/terracognita-git 1:v0.3.0.r27.gdfc5a99-1 (+0 0.00%) 
    Reads from existing Cloud Providers (reverse Terraform) and generates your infrastructure as code on Terraform configuration
1
2
3
4
5

# Usage

Using the terracognita --help you will know the basics.

$ make help
help: Makefile                   This help dialog
lint: $(GOLANGCI_LINT) $(GOLINT) Runs the linter
test:                            Runs the tests
ci: lint test                    Runs the linter and the tests
dbuild:                          Builds the docker image with same name as the binary
build:                           Bulids the binary
clean:                           Removes binary and/or docker image
1
2
3
4
5
6
7
8

asciicast

# Docker

You can use directly the image built, or you can build your own. To build your Docker image just run:

$ make dbuild
1

And then depending on the image you want to use (cycloid/terracognita or your local build terracognita):

$ docker run cycloid/terracognita -h
1

Example:

$ export AWS_ACCESS_KEY_ID=XXXXXXXXXXXXXXXXXXXX
$ export AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
$ export AWS_DEFAULT_REGION=xx-yyyy-0
$ docker run \
		-v "${PWD}"/outputs:/app/outputs \
		cycloid/terracognita aws \
		--access-key="${AWS_ACCESS_KEY_ID}" \
		--secret-key="${AWS_SECRET_ACCESS_KEY}" \
		--region="${AWS_DEFAULT_REGION}" \
		--hcl app/outputs/resources.tf
1
2
3
4
5
6
7
8
9
10

# Local

The local version can be used the same way as docker. You simply need to be build it locally.

# To test

To speed up the testing, you can write a small provider.tffile within the same folder you imported your resources & tfstate:

terraform {
 backend "local" {
   path = "./$TFSTATE_PATH"
 }
}

provider "aws" {
 access_key = "${var.access_key}"
 secret_key = "${var.secret_key}"
 region     = "${var.region}"
 version    = "2.12.0"
}

variable "access_key" {}
variable "secret_key" {}
variable "region" {}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Then run the terraform init & plan commands:

$ terraform init
$ terraform plan -var access_key=$AWS_ACCESS_KEY_ID -var secret_key=$AWS_SECRET_ACCESS_KEY -var region=$AWS_DEFAULT_REGION
1
2

# License

Please see the MIT LICENSE file.

# Changelog

All notable changes to this project will be documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.