ukayani

#!/bin/bash
DOCKER_MIRROR_HOST=$(/sbin/ip route | awk '/default/ { print $3 }')

DOCKER_MIRROR_PORT=${MIRROR_PORT:-9001}
DOCKER_MIRROR="http://$DOCKER_MIRROR_HOST:$DOCKER_MIRROR_PORT"

# HOSTNAME is the Docker container ID, docker initializes this variable to the container ID
# APP_PORT is the container Port
export HOST_IP=$(curl $DOCKER_MIRROR/hostip)
export HOST_PORT=$(curl $DOCKER_MIRROR/container/$HOSTNAME/port/$APP_PORT)

ukayani

dockerBaseImage := "loyaltyone/dakka:0.5"
dockerEntrypoint := "/usr/local/bin/bootstrap" +: dockerEntrypoint.value

ukayani

"TaskDefinition": {
      "Type": "AWS::ECS::TaskDefinition",
      "Properties": {
        "ContainerDefinitions": [{
          "Name": "theatre-example",
          "Image": "loyaltyone/theatre-example:latest",
          "PortMappings": [{
            "ContainerPort": 8080,
            "HostPort": 0
          }, {

ukayani

"Service": {
            "Type": "AWS::ECS::Service",
            "Properties": {
                "ServiceName": "theatre-service",
                "TaskDefinition": {
                    "Ref": "TaskDefinition"
                },
                "DesiredCount": 3,
                "LoadBalancers": [
                    {

ukayani

// Goal:  Be able to do a curl from local to  server in AWS private subnet
// Host - The machine running the server in a private subnet
// Bastion - A machine which has access to the Host in the private subnet. You need to have SSH access to this machine
// Local - Your local machine

// Normally, if you SSH into your Bastion, you are able to curl the DNS/IP of the private Host machine running your server
// To be able to curl from your local machine, you'll need to set up a tunnel between your local and the bastion
// When you tunnel, you have to provide the DNS/IP of the private Host as seen from the Bastion. This will typically be a private IP
// an internal DNS name

ukayani

object Stage {
/**
    * A source which feeds an initial batch into a provided flow and emits when entire batch is completed while retrying
    * unprocessed elements with a backoff strategy.
    *
    * The provided flow must accept a set of elements and emit a subset containing unprocessed items or an empty set if
    * all elements are processed successfully
    *
    * @param flow a flow which processes sets at a time and emits corresponding sets containing unprocessed items (if any)
    * @param minBackoff min time to back off when retrying unprocessed elements

ukayani

val mavenResolver = sys.env.get("TOKEN").map(token => Seq("repo" at s"https://repourl/maven2"))
resolvers ++= mavenResolver.getOrElse(Seq.empty[Resolver])

ukayani

#!/usr/bin/env bash

set -o pipefail
set -o nounset # fail on unset var usage
set -o errexit # exit on command failure

err_report() {
    echo "Exited with error on line $1"
}
# prints errors out along with line number

ukayani

#!/bin/bash

# Lets say we have all resources under state /A using module A
# We decide to wrap all the resources of the module into a inner module B
# So now all resources that were orignally top level in A are now top level in B
# Normally if we try to plan our changes, terraform will want to delete all resources originally under A and create new ones under B
# However, we may not want that (what if our resources are vpc level resources that we cant afford to delete)
# Terraform provides a state move command
# We can list all the resources in a module via `terraform state list`
# We can pipe this list to xargs and for each resource we can move it to the new prefix, ie. under inner module B.

ukayani

resource "local_file" "kube_config" {
  content  = "${var.kube_config}"
  filename = "${path.module}/kubeconfig"
}

# Hacky way to force a dependency on some external resource (since modules dont support a depends_on)
data "template_file" "deps" {
  template = "${join(",", var.depends_on)}"
}