Docker based Angular development environment

README.md

Introduction

The following instructions assume execution on a MacBook Pro (15-inch, Early 2011) or later running OS X Yosemite ^10.10.x. with an Intel Core i7 64bit processor.

Prerequisites

Open Source

Git, Docker, [Docker Toolbox] (https://www.docker.com/toolbox), [Parallels Desktop ^11.x Docker Machine driver] (https://github.com/Parallels/docker-machine)

Commercial

[Parallels Desktop ^11.x] (http://www.parallels.com/products/desktop/)

Building with Docker-machine Parallels driver on OSX

1. git clone https://github.com/Con-way/ig.git
2. cd ig
3. docker-machine create -d parallels prl-dev
4. eval "$(docker-machine env prl-dev)"
5. docker build -t cnw/ig .
6. docker run -it --rm -v $(pwd):/src cnw/ig npm install
7. docker run -it -p 9000:9000 -p 35729:35729 --rm -v $(pwd):/src cnw/ig grunt serve
8. curl -IG http://$(docker-machine ip prl-dev):9000

Lunch and Learn Idea

Potential topic areas for a lunch-and-learn (maybe sponsored by Docker, New Relic, or Puppet) to cover the container, boxing, and virtualization spaces. Specifically, what differences there are and why a company might choose one path over another.

My limited understanding leads me to believe that Virtual Desktop Instances (VDI) provide you with a complete desktop computer experience served from a central "server" for either short-term or long-term use. The instances could be remotely accessed, but for performance reasons they are often fronted by a thin-client. Here you sacrifice network bandwidth and I/O performance for centralized management and reproducible environments. Good use cases are for users who don't require high-throughput or I/O intensive operations like Word processing and accessing cloud services.

The next step along the spectrum toward a decentralized, virtual development and deployment environment is using boxes. The tool of choice here is Vagrant by Hashicorp. Vagrant allows you to create a base box which can be used as the foundation of a number of later box builds. A completed box is a Virtual Machine which can run within a software hypervisor like VirtualBox, VMWare, Parallels, etc. There are even plugins to create VMs capable of running in cloud providers like Azure or AWS. To create a running vm in Virtualbox (for instance) you checkout/copy the Vagrantfile configuration into a directory, cd into that directory, and execute the command "vagrant up." Once finished, you have a complete virtual machine running in your hypervisor. This vm is tied to the machine you ran vagrant up on and the provider that was targeted. If you went to another machine or provider you would have to run vagrant up again and the vm would be created there. Another point to mention is that vagrant only covers vm creation not provisioning. There are a number of plugins for things like Puppet, Chef, Ansible, Bash, etc. which allow the installation of packages and configuration during a provisioning step after the build.

The final step toward the nirvana of decentralized, reproducible, worry-free development is the use of container technology like Docker. Here there is a Dockerfile which describes the base image as well as any provisioning commands. The output of the process is a container image which like the yoke of an egg is surrounded by the nutrients it needs to exist. Once you run "docker build", the Dockerfile is read, the base image downloaded, and the provisioning steps executed, followed by a default command to execute unless one is provided on the command line. A docker image doesn't care what kind of machine its on, only that there is a docker daemon which takes care of the OS abstraction. You can copy an image after build to another box and "docker run" it. A docker image is tagged and named, so it's often the output of a build process in which case the docker image build for QA is run unchanged on production, once it has passed all the change management steps. No rebuilding for each system or worrying that an up-steam system is patched to the same level as the downstream test systems -- the patch levels and all other system dependencies are encapsulated into the docker image.

That's just a quick mental dump of what I see as the major competing themes in this arena. The use of containers has launched a new specialization area around the operation, management, and orchestration of containers. With docker, an application which has a web layer, service layer, and db layer, could have at least three containers orchestrated together to make up a usable application. Each layer can therefore be scaled up or down to provide a high-definition, agile end-user experience. Leaving the customer full of smiles and congratulations.

Dockerfile

# Debian system for running a yeoman scaffolded angular app
FROM debian:latest

ENV DEBIAN_FRONTEND noninteractive

RUN apt-get -yq update && \
    apt-get -yq install python-software-properties software-properties-common \
                        git curl net-tools sudo bzip2 libpng-dev locales-all \
                        python g++ make ruby-compass libfreetype6

RUN curl -sL https://deb.nodesource.com/setup_0.12 | bash - && \
    apt-get -yq install nodejs ruby-compass

RUN npm install -g npm && \
    npm install -g bower grunt-cli jspm

# create a new user because grunt doesn't like running as root
RUN adduser --disabled-password --gecos "" --home "/home/app" app; \
    echo "app ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers


# set HOME so 'npm install' and 'bower install' don't write to /
ENV HOME /home/app

ENV LANG en_US.UTF-8

RUN mkdir /src && chown app:app /src
WORKDIR /src

ADD set_env.sh /usr/local/sbin/
RUN chmod +x /usr/local/sbin/set_env.sh
ENTRYPOINT ["set_env.sh"]

# Run as app user
USER app
RUN git config --global url."https://".insteadOf git://

# Expose the compass server port and live reload ports to the host
# If running on OSX or Windows the ip address to access the port is the
# ip of the boot2docker or docker-machine.

EXPOSE 9000 35729

# default run command if none is provided
CMD ["/bin/bash"]

Makefile

# Simple Makefile for use with make
# See, https://www.digitalocean.com/community/tutorials/how-to-use-makefiles-to-automate-repetitive-tasks-on-an-ubuntu-vps

PROJECT		 ?= cnw/ig
TAG				 ?= latest

ifdef REGISTRY
	IMAGE=$(REGISTRY)/$(PROJECT):$(TAG)
else
	IMAGE=$(PROJECT):$(TAG)
endif

test:


build: Dockerfile
		docker build -t $(IMAGE) .

install: Dockerfile
		docker run -it --rm -v $(shell pwd):/src $(IMAGE) npm install

serve: Dockerfile
		docker run -it -p 9000:9000 -p 35729:35729 --rm -v $(shell pwd):/src $(IMAGE) grunt serve

clean:
		docker rmi $(PROJECT):$(TAG)

set_env.sh

#!/bin/bash

set -eu

export DOCKER_HOST_IP=`netstat -nr | grep '^0\.0\.0\.0' | awk '{print $2}'`

"$@"