terra's Introduction

Terra

Terra lets you write Terraform configurations using pure Clojure.

Motivation

Have the full power of Clojure at your fingertips when defining Terraform configurations.
Do you need to iterate through something? Or maybe you need to automate part of the configuration creation? Just use the tools you are used to.
No need to learn a separate configuration language in details. A simple Clojure EDN will do.

Getting Started
Usage
Advanced
Bugs
Help!

Getting Started

Add the following dependency to your project.clj file:

Add the following plugin to your :plugins in your project.clj file:

Usage

Create a namespace in your project and require terra.core on your stateful component:

(ns my-project.infrastructure.core
  (:require [terra.core :as terra :refer [defterra $]))

Notice we are also referring the macros defterra and $.

We are going to create an example_ec2 definition using defterra. If you have done any Terraform before, this should be familiar to you.

(defterra example_ec2 {:provider {:aws {:region :us-east-1}}
                       :resource {:aws_instance {:example {:ami :ami-2757f631
                                                           :instance_type :t2.micro}}}})

According to this definiation, example_ec2 uses AWS in the us-east-1 region. It is a t2.micro instance using ami-2757f631. We have used keywords but strings also work if you prefer.

The next step is creating a handler function for trigering the generation of your Terraform file. Usually you just want to call terra/generate in it.

(defn handler []
  (terra/generate))

Then add the following to your project.clj:

:terra {:handler my-project.infrastructure.core/handler}

Head to your terminal and type:

$ lein terra

You should see:

Terra: generating...
Terra: terraform/my-project.infrastructure.core/example_ec2.tf.json
Terra: done!

You can now plan and then apply your Terraform configuration by:

$ cd terraform/my-project.infrastructure.core
$ terraform plan
...
$ terraform apply
...

Since the terraform files are always generated, it is recommended that you add the terraform directory to your .gitignore.

Advanced

The $ macro is a small utility helper to write Terraform interpolations in a more Clojure-like way.

For instance, in order to interpolate a variable, simply use:

:count ($ var.count)

If you want the entry :us-east-1 from the list var.amis, simply use:

:ami ($ (:us-east-1 var.amis))

The traditional get also works here:

:ami ($ (get var.amis :us-east-1))

This also works for indexes:

:ami ($ (get var.amis 0))

Last but not least, you can specify a call to Terraform's functions as if they were Clojure functions with:

:file ($ (file "path.txt"))

One last trick that might be interesting for you is that the defterra macro is just syntax sugar for a simple def. You can also specify your Terraform definitions by using the meta ^:terraform:

(def ^:terraform example_ec2 {:provider {:aws {:region :us-east-1}}
                              :resource {:aws_instance {:example {:ami :ami-2757f631
                                                                  :instance_type :t2.micro}}}})

Bugs

If you find a bug, submit a Github issue.

Help

This project is looking for team members who can help this project succeed! If you are interested in becoming a team member please open an issue.

License

Distributed under the MIT License.

terra's People

Stargazers

Watchers

terra's Issues

Some kind of "spread operator"

Here is a common use-case.

Let's say we have two modules:

module "infrastructure" {
  source = "./infrastructure"
}

module "pipeline" {
  source                           = "./pipeline"
  dev_google_analytics_topic_arn   = "${module.infrastructure.dev_google_analytics_topic_arn}"
  dev_report_cursors_queue_arn     = "${module.infrastructure.dev_report_cursors_queue_arn}"
  dev_report_cursors_queue_url     = "${module.infrastructure.dev_report_cursors_queue_url}"
  stage_google_analytics_topic_arn = "${module.infrastructure.stage_google_analytics_topic_arn}"
  stage_report_cursors_queue_arn   = "${module.infrastructure.stage_report_cursors_queue_arn}"
  stage_report_cursors_queue_url   = "${module.infrastructure.stage_report_cursors_queue_url}"
  prod_google_analytics_topic_arn  = "${module.infrastructure.prod_google_analytics_topic_arn}"
  prod_report_cursors_queue_arn    = "${module.infrastructure.prod_report_cursors_queue_arn}"
  prod_report_cursors_queue_url    = "${module.infrastructure.prod_report_cursors_queue_url}"
}

Infrastructure is exposing:

output "dev_google_analytics_topic_arn" {
  value = "${module.dev.google_analytics_topic_arn}"
}

output "dev_report_cursors_queue_arn" {
  value = "${module.dev.report_cursors_queue_arn}"
}

output "dev_report_cursors_queue_url" {
  value = "${module.dev.report_cursors_queue_url}"
}

output "dev_report_cursor_failures_queue_arn" {
  value = "${module.dev.report_cursor_failures_queue_arn}"
}

output "dev_report_cursor_failures_queue_url" {
  value = "${module.dev.report_cursor_failures_queue_url}"
}

output "stage_google_analytics_topic_arn" {
  value = "${module.stage.google_analytics_topic_arn}"
}

output "stage_report_cursors_queue_arn" {
  value = "${module.stage.report_cursors_queue_arn}"
}

output "stage_report_cursors_queue_url" {
  value = "${module.stage.report_cursors_queue_url}"
}

output "stage_report_cursor_failures_queue_arn" {
  value = "${module.stage.report_cursor_failures_queue_arn}"
}

output "stage_report_cursor_failures_queue_url" {
  value = "${module.stage.report_cursor_failures_queue_url}"
}

output "prod_google_analytics_topic_arn" {
  value = "${module.prod.google_analytics_topic_arn}"
}

output "prod_report_cursors_queue_arn" {
  value = "${module.prod.report_cursors_queue_arn}"
}

output "prod_report_cursors_queue_url" {
  value = "${module.prod.report_cursors_queue_url}"
}

output "prod_report_cursor_failures_queue_arn" {
  value = "${module.prod.report_cursor_failures_queue_arn}"
}

output "prod_report_cursor_failures_queue_url" {
  value = "${module.prod.report_cursor_failures_queue_url}"
}

And, as seen above, these get "piped" out by pipeline.

This is a lot of repetitive work. Some kind of helper function/macro would be highly appreciated.

Make `$` support a simple form of conditionals

It could accept something like :count ($ (if (== "dev" var.env) 1 10))

The challenge here is supporting nested forms plus extra support for each Terraform operator (i.e. should we use Terraform's == instead of =?)

Recommend Projects

luchiniatwork / terra Goto Github PK

terra's Introduction

Terra

Motivation

Table of Contents

Getting Started

Usage

Advanced

Bugs

Help

License

terra's People

Stargazers

Watchers

Forkers

terra's Issues

Some kind of "spread operator"

Make `$` support a simple form of conditionals

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent