Skip to content
Reads from existing Cloud Providers (reverse Terraform) and generates your infrastructure as code on Terraform configuration
Go Makefile Dockerfile
Branch: master
Clone or download
xescugc Merge pull request #80 from cycloidio/fg-40
Addeed: New flag '--target'
Latest commit 5709caa Jan 3, 2020
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.ci .ci: Update the PP to use the 'IS_CI' flag on the 'make lint' Sep 25, 2019
.github/ISSUE_TEMPLATE template: add bug_report template Nov 28, 2019
aws README: Remove last links to 'raws' Dec 18, 2019
cache cache: Use the new 'prvider.NewResource' Oct 29, 2019
cmd
errcode filter: Add a 'Validate' and 'TargetTypesWithIDs' methods Jan 3, 2020
filter filter: Add a 'Validate' and 'TargetTypesWithIDs' methods Jan 3, 2020
google google: add google cloud sql instance component Dec 18, 2019
hcl Rebase: Conflicts solved aftert the rebase from master Oct 29, 2019
log log: Add the log Singelton Jul 18, 2019
mock mock: Update the mocks Oct 29, 2019
provider provider: Add the logic of the Filter.Targets Jan 3, 2020
state Rebase: Conflicts solved aftert the rebase from master Oct 29, 2019
tag tag: Add tests for it Jun 14, 2019
util util: Fix retry that always retries all errors Oct 29, 2019
writer Rebase: Conflicts solved aftert the rebase from master Oct 29, 2019
.gitignore .gitignore: Remove the [Ll]og to be able to track the new folder Jul 18, 2019
CHANGELOG.md CHANGELOG: New flag Jan 3, 2020
CONTRIBUTING.md CONTRIBUTING: Update the documentation Dec 17, 2019
Dockerfile
LICENSE doc: update Makefile and add documentation Jun 4, 2019
Makefile Makefile: Delete the mocks before creating them again Oct 29, 2019
README.md README: Remove last links to 'raws' Dec 18, 2019
go.mod mod: Remove 'raws' Dec 17, 2019
go.sum mod: Remove 'raws' Dec 17, 2019
main.go Rename from Terraforming to Terracognita Jun 3, 2019

README.md

TerraCognita

GoDoc Gitter chat

Imports 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.

Installation

It uses Go Modules, so GO 1.11+ is required. If you wish to run it via docker then docker binary is required. While if you wish to run it locally; you will need to have the extra brz lib installed.

You have 2 options to get the package:

  • Clone the repository to $GOPATH/src/github.com/cycloidio/terracognita
  • go get -d github.com/cycloidio/terracognita

Then feel free to play with it :)

$> cd $GOPATH/src/github.com/cycloidio/terracognita
$> make install

Versions

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

Terraform: 0.12.7

Providers:

  • AWS: 2.31.0
  • GCP: 2.16.0

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

asciicast

Docker

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

$ make dbuild

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

$ docker run cycloid/terracognita -h

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

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" {}

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

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.

About Cycloid

Cycloid is a European fully-remote company, building a product to simplify, accelerate and optimize your DevOps and Cloud adoption.

We built Cycloid, your DevOps platform to encourage Developers and Ops to work together with the respect of best practices. We want to provide a tool that eliminates the silo effect in a company and allows to share the same level of informations within all professions.

Cycloid supports you to factorize your application in a reproducable way, to deploy a new environment in one click. This is what we call a stack.

A stack is composed of 3 pillars:

  1. the pipeline (Concourse)
  2. infrastructure layer (Terraform)
  3. applicative layer (Ansible)

Thanks to the flexible pipeline, all the steps and technologies are configurable.

To make it easier to create a stack, we build an Infrastructure designer named StackCraft that allows you to drag & drop Terraform ressources and generate your Terraform files for you.

Terracognita is a brick that will help us to import an existing infrastructure into a stack to easily adopt Cycloid product.

The product comes also with an Open Source service catalog (all our public stacks are on Github) to deploy applications seamlessly. To manage the whole lifecycle of an application, it also integrates the diagram of the infrastructure and the application, a cost management control to centralize Cloud billing, the monitoring, logs and events centralized with Prometheus, Grafana, ELK.

Don't hesitate to contact us, we'll be happy to meet you !

You can’t perform that action at this time.