ufo 3.5.7 → 4.0.0

data/docs/_docs/tutorial-ufo-init.md

@@ -2,36 +2,37 @@
 title: Setup Ufo
 ---
 
-The easiest way to create this ufo folder is by using the `ufo init` command.  For this tutorial we'll [tongueroo/hi](https://github.com/tongueroo/hi) which is a small test sinatra app.
+The easiest way to create this ufo folder is by using the `ufo init` command.  For this tutorial we'll [tongueroo/demo-ufo](https://github.com/tongueroo/demo-ufo) which is a small test sinatra app.
 Let's run the command in our newly cloned project.
 
 ```sh
-git clone https://github.com/tongueroo/hi.git
-cd hi
-ufo init --app=hi --image=tongueroo/hi
+git clone https://github.com/tongueroo/demo-ufo.git
+cd demo-ufo
+ufo init --app=demo --image=tongueroo/demo-ufo
 ```
 
 You should see output similiar to this:
 
 ```sh
-$ ufo init --app=hi --image=tongueroo/hi
+$ ufo init --app=demo --image=tongueroo/demo-ufo
 Setting up ufo project...
       create  .env
+      create  .ufo/params.yml
       create  .ufo/settings.yml
+      create  .ufo/settings/cfn/default.yml
+      create  .ufo/settings/network/default.yml
       create  .ufo/task_definitions.rb
+      create  .ufo/templates/fargate.json.erb
       create  .ufo/templates/main.json.erb
       create  .ufo/variables/base.rb
       create  .ufo/variables/development.rb
       create  .ufo/variables/production.rb
-      create  Dockerfile
+   identical  Dockerfile
       create  bin/deploy
       append  .gitignore
+      create  .dockerignore
 Starter ufo files created.
-$ ufo ship hi-web
-Building docker image with:
-  docker build -t tongueroo/hi:ufo-2017-09-10T15-00-19-c781aaf -f Dockerfile .
-....
-Software shipped!
+Congrats 🎉 You have successfully set up ufo for your project.
 $
 ```
 
@@ -59,10 +60,13 @@ Take a look at the `settings.yml` file and notice that it contains some default
 ```yaml
 # More info: http://ufoships.com/docs/settings/
 base:
-  image: tongueroo/hi
+  image: tongueroo/demo-ufo
   # clean_keep: 30 # cleans up docker images on your docker server.
   # ecr_keep: 30 # cleans up images on ECR and keeps this remaining amount. Defaults to keep all.
   # defaults when an new ECS service is created by ufo ship
+  network_profile: default # .ufo/settings/network/default.yml file
+  cfn_profile: default # .ufo/settings/cfn/default.yml file
+
 development:
   # cluster: dev # uncomment if you want the cluster name be other than the default
                  # the default is to match UFO_ENV.  So UFO_ENV=development means the ECS

data/docs/_docs/tutorial-ufo-ship.md

@@ -7,91 +7,87 @@ title: Deploy One App
 In this guide we have walked through what ufo does step by step.  First ufo builds the Docker image with `ufo docker build`.  Then it will build and register the ECS task definitions with the `ufo tasks` commands. Now we'll deploy the code to ECS.
 
 ```sh
-ufo ship hi-web
+ufo ship demo-web
 ```
 
 By convention, ufo will ship the docker container to an ECS cluster with the same value as UFO_ENV, which defaults to development.  So the command above is the same as:
 
 ```sh
-ufo ship hi-web --cluster production
-UFO_ENV=production ufo ship hi-web --cluster prod
+ufo ship demo-web --cluster development
+UFO_ENV=development ufo ship demo-web
 ```
 
-When you run `ufo ship hi-web`:
+When you run `ufo ship demo-web`:
 
 1. It builds the docker image.
 2. Generates a task definition and registers it.
 3. Updates the ECS service to use it.
 
-If the ECS service hi-web does not yet exist, ufo will create the service for you. Ufo will also automatically create the ECS cluster.
+If the ECS service demo-web does not yet exist, ufo will create the service for you. Ufo will also automatically create the ECS cluster.
 
-NOTE: If you are relying on this tool to create the cluster, you still need to associate ECS Container Instances to the cluster yourself.
+NOTE: Ufo creates the ECS cluster record, but you still need to associate ECS Container Instances to the cluster yourself.
 
-By convention, if the service has a container name web, you'll get prompted to create an ELB and specify a target group ARN.  The ELB and target group must already exist. You can bypass the prompt and specify the target group ARN as part of the ship command or with the `--no-target-group-prompt` option.  The ELB target group only gets associated with the ECS service if the service is being created for the first time.  If the service already exists then the `--target-group` parameter just gets ignored and the ECS task simply gets updated.  Example:
-
-
-```bash
-ufo ship hi-web --target-group=arn:aws:elasticloadbalancing:us-east-1:12345689:targetgroup/hi-web/12345
-```
-
-Let's go back to the original command and take a look at the output:
+By convention, if the service has a container name web, ufo will automatically create an Load Balancer.  Let's take a look at the example out from the `ufo ship`.  Some of the output has been removed for conciseness.
 
 ```sh
-ufo ship hi-web
-```
-
-The output should look something like this (some of the output has been removed for conciseness):
-
-```sh
-$ ufo ship hi-web
+$ ufo ship demo-web
 Building docker image with:
-  docker build -t tongueroo/hi:ufo-2017-06-12T06-46-12-a18aa30 -f Dockerfile .
+  docker build -t tongueroo/demo-ufo:ufo-2018-06-28T16-41-11-7e0af94 -f Dockerfile .
+...
+Deploying demo-web...
+Ensuring log group for demo-web task definition exists
+Log group name: ecs/demo-web
+Creating stack development-demo-web...
+Generated template saved at: /tmp/ufo/development-demo-web/stack.yml
+Generated parameters saved at: /tmp/ufo/development-demo-web/parameters.yml
+04:41:27PM CREATE_IN_PROGRESS AWS::CloudFormation::Stack development-demo-web User Initiated
+04:41:31PM CREATE_IN_PROGRESS AWS::EC2::SecurityGroup ElbSecurityGroup
+04:41:31PM CREATE_IN_PROGRESS AWS::EC2::SecurityGroup EcsSecurityGroup
+04:41:31PM CREATE_IN_PROGRESS AWS::ElasticLoadBalancingV2::TargetGroup TargetGroup
+04:41:31PM CREATE_IN_PROGRESS AWS::EC2::SecurityGroup ElbSecurityGroup Resource creation Initiated
+04:41:32PM CREATE_IN_PROGRESS AWS::EC2::SecurityGroup EcsSecurityGroup Resource creation Initiated
+04:41:32PM CREATE_IN_PROGRESS AWS::ElasticLoadBalancingV2::TargetGroup TargetGroup Resource creation Initiated
 ...
-Pushed tongueroo/hi:ufo-2017-06-12T06-46-12-a18aa30 docker image. Took 9s.
-Building Task Definitions...
-Generating Task Definitions:
-  ufo/output/hi-web.json
-  ufo/output/hi-worker.json
-  ufo/output/hi-clock.json
-Task Definitions built in ufo/output.
-hi-web task definition registered.
-Shipping hi-web...
-hi-web service updated on stag cluster with task hi-web
+04:44:46PM CREATE_COMPLETE AWS::ECS::Service Ecs
+04:44:48PM CREATE_COMPLETE AWS::CloudFormation::Stack development-demo-web
+Stack success status: CREATE_COMPLETE
+Time took for stack deployment: 3m 22s.
 Software shipped!
-Cleaning up docker images...
-Running: docker rmi tongueroo/hi:ufo-2017-06-11T20-32-16-a18aa30 tongueroo/hi:ufo-2017-06-11T20-27-44-bc80e84 tongueroo/hi:ufo-2017-06-11T20-02-18-bc80e84
+$
 ```
 
 Checking the ECS console you should see something like this:
 
 <img src="/img/tutorials/ecs-console-ufo-ship.png" class="doc-photo" />
 
-You have successfully shipped a docker image to ECS! 🍾🥂
+You have successfully deployed a Docker image to ECS! 🍾🥂
 
-## Skipping Previous Steps Method
+## Checking ECS Service
 
-You should notice that `ufo ship` re-built the docker image and re-registered the task definitions.  The `ufo ship` command is designed to run everything in one simple command, so we do not have to manually call the commands in the previous pages: `ufo build` and `ufo tasks`.
+Another way to check that the ECS service is running is with the `ufo ps` command.
 
-If you would like to skip the first 2 steps, then you can use the [ufo deploy]({% link _reference/ufo-deploy.md %}) instead.  The `ufo deploy` command will:
+    $ ufo ps demo-web
+    => Service: demo-web
+       Service name: development-demo-web-Ecs-12DRF2703Z3D2
+       Status: ACTIVE
+       Running count: 1
+       Desired count: 1
+       Launch type: EC2
+       Task definition: demo-web:82
+       Elb: develop-Elb-ZY1VARS3KP14-2141687965.us-east-1.elb.amazonaws.com
+    +----------+------+-------------+---------------+---------+-------+
+    |    Id    | Name |   Release   |    Started    | Status  | Notes |
+    +----------+------+-------------+---------------+---------+-------+
+    | e4426421 | web  | demo-web:82 | 5 minutes ago | RUNNING |       |
+    +----------+------+-------------+---------------+---------+-------+
 
-1. register the task definition in `.ufo/output/hi-web.json` unmodified
-2. update the ECS service
+## Ufo Current Tip
 
-Example:
-
-```sh
-ufo deploy hi-web
-```
-
-The output should look something like this:
-
-```sh
-Shipping hi-web...
-hi-web service updated on stag cluster with task hi-web
-Software shipped!
-```
+We've been typing the `demo-web` service name explicitly.  We can set the current service with the `ufo current` command to save us from typing each time.  Example:
 
-Normally you run everything together in one `ufo ship` command though.  Ufo takes a multiple step process and simplifies it down to a single command!
+    ufo current --service demo-web
+    ufo ship # now same as ufo ship demo-web
+    ufo ps # now same as ufo ps demo-web
 
 Congratulations 🎊 You have successfully built a Docker image, register it and deployed it to AWS ECS.
 

data/docs/_docs/tutorial-ufo-ships.md

@@ -2,16 +2,16 @@
 title: Deploy Multiple Apps
 ---
 
-You might have noticed in in the tutorial that the generated starter ufo folder contains 3 task definitions a `web`, `worker` and `clock` role.  This is a common pattern.  The web process handles web traffic, the worker process handles background job processing that would be too slow and potentially block web requests, and a clock process is typically used to schedule recurring jobs.
+You might have noticed in the tutorial that the generated starter .ufo folder contains 3 task definitions a `web`, `worker` and `clock` role.  This is a common pattern.  The web process handles web traffic, the worker process handles background job processing that would be too slow and potentially block web requests, and a clock process is typically used to schedule recurring jobs.
 
-These processes use the same codebase and same docker image, but have slightly different run time settings.  The docker run command for a web process could be [puma](http://puma.io/) and the command for a worker process could be [sidekiq](http://sidekiq.org/).  Environment variables are also sometimes different.  The important key is that the same docker image is used for all 3 services but the task definition for each service is slightly different.
+These processes typically use the same codebase and same docker image, but have slightly different run time settings.  The docker run command for a web process could be [puma](http://puma.io/) and the command for a worker process could be [sidekiq](http://sidekiq.org/).  Environment variables are also sometimes different.  The important key is that the same docker image is used for all 3 services but the task definition for each service is slightly different.
 
 While we can use the `ufo ship` command to deploy to all 3 service roles individually like so:
 
 ```sh
-ufo ship hi-web
-ufo ship hi-worker
-ufo ship hi-clock
+ufo ship demo-web
+ufo ship demo-worker
+ufo ship demo-clock
 ```
 
 This would build a new Docker image for each process.  We actually want have the same docker image running on all of these roles.  In this case where we want to use the *same* Docker image for all 3 roles, ufo provides a `ufo ships` command.
@@ -19,7 +19,7 @@ This would build a new Docker image for each process.  We actually want have the
 ## ufo ships
 
 ```sh
-ufo ships hi-web hi-worker hi-clock
+ufo ships demo-web demo-worker demo-clock
 ```
 
 You can check on the ECS console and should see something similar to this:
@@ -29,9 +29,11 @@ You can check on the ECS console and should see something similar to this:
 You can shorten the command by taking advantage of shell expansion:
 
 ```sh
-ufo ships hi-{web,worker,clock}
+ufo ships demo-{web,worker,clock}
 ```
 
+In the case of the `ufo ships` command the `--wait` option defaults to false so that all the specified ECS services update in parallel.  You can check on the status of the update on the CloudFormation console.
+
 <a id="prev" class="btn btn-basic" href="{% link _docs/tutorial-ufo-ship.md %}">Back</a>
 <a id="next" class="btn btn-primary" href="{% link docs.md %}">Next Step</a>
 <p class="keyboard-tip">Pro tip: Use the <- and -> arrow keys to move back and forward.</p>

data/docs/_docs/tutorial-ufo-tasks-build.md

@@ -39,7 +39,7 @@ The instance variable values are specified in `.ufo/task_definitions.rb` via a D
 **.ufo/task_definitions.rb**:
 
 ```
-task_definition "hi-web" do
+task_definition "demo-web" do
   source "main" # will use ufo/templates/main.json.erb
   variables(
     family: task_definition_name,
@@ -49,7 +49,7 @@ task_definition "hi-web" do
   )
 end
 
-task_definition "hi-worker" do
+task_definition "demo-worker" do
   source "main" # will use ufo/templates/main.json.erb
   variables(
     family: task_definition_name,
@@ -66,7 +66,7 @@ Ufo has a concept of shared variables, covered in [Shared Variables]({% link _do
 **.ufo/variables/base.rb**:
 
 ```ruby
-@image = helper.full_image_name # includes the git sha tongueroo/hi:ufo-[sha].
+@image = helper.full_image_name # includes the git sha tongueroo/demo-ufo:ufo-[sha].
 @cpu = 128
 @memory_reservation = 256
 @environment = helper.env_file(".env")
@@ -99,27 +99,28 @@ You should see output similar to below:
 $ ufo tasks build
 Building Task Definitions...
 Generating Task Definitions:
-  .ufo/output/hi-web.json
-  .ufo/output/hi-worker.json
-  .ufo/output/hi-clock.json
+  .ufo/output/demo-web.json
+  .ufo/output/demo-worker.json
+  .ufo/output/demo-clock.json
 Task Definitions built in .ufo/output
 $
 ```
 
-Let's take a look at one of the generated files: `.ufo/output/hi-web.json`.
+Let's take a look at one of the generated files: `.ufo/output/demo-web.json`.
 
 ```json
 {
-  "family": "hi-web",
+  "family": "demo-web",
   "containerDefinitions": [
     {
       "name": "web",
-      "image": "tongueroo/hi:ufo-2018-02-13T11-33-15-27aa242",
-      "cpu": 192,
-      "memoryReservation": 256,
+      "image": "tongueroo/demo-ufo:ufo-2018-06-29T23-20-47-20b3a10",
+      "cpu": 256,
+      "memory": 512,
+      "memoryReservation": 512,
       "portMappings": [
         {
-          "containerPort": "3000",
+          "containerPort": 4567,
           "protocol": "tcp"
         }
       ],
@@ -137,9 +138,9 @@ Let's take a look at one of the generated files: `.ufo/output/hi-web.json`.
       "logConfiguration": {
         "logDriver": "awslogs",
         "options": {
-          "awslogs-group": "ecs/hi-web",
+          "awslogs-group": "ecs/demo-web",
           "awslogs-region": "us-east-1",
-          "awslogs-stream-prefix": "hi"
+          "awslogs-stream-prefix": "demo"
         }
       },
       "essential": true
@@ -159,9 +160,17 @@ ufo tasks register
 You should see something similar to this:
 
 ```sh
-hi-clock task definition registered.
-hi-web task definition registered.
-hi-worker task definition registered.
+$ ufo tasks register
+Equivalent aws cli command:
+  aws ecs register-task-definition --cli-input-json file://.ufo/output/demo-web.json
+demo-web task definition registered.
+Equivalent aws cli command:
+  aws ecs register-task-definition --cli-input-json file://.ufo/output/demo-clock.json
+demo-clock task definition registered.
+Equivalent aws cli command:
+  aws ecs register-task-definition --cli-input-json file://.ufo/output/demo-worker.json
+demo-worker task definition registered.
+$
 ```
 
 <a id="prev" class="btn btn-basic" href="{% link _docs/tutorial-ufo-docker-build.md %}">Back</a>

data/docs/_docs/ufo-current.md

@@ -0,0 +1,50 @@
+---
+title: Ufo Current
+---
+
+## service
+
+There's a handy way to shorten ufo commands by setting the current service.  Example:
+
+    ufo ship demo-web # normal usage
+    ufo current --service demo-web
+    ufo ship # no longer have to type: demo-web
+
+To view the current settings run `ufo current` with no options.
+
+    $ ufo current
+    Current env_extra: 1
+    Current service: demo-web
+
+Setting the current service helps shorten other commands also:
+
+    ufo cancel
+    ufo deploy
+    ufo destroy
+    ufo ps
+    ufo releases
+    ufo resources
+    ufo rollback VERSION
+    ufo scale COUNT
+    ufo ship
+
+## UFO_ENV_EXTRA
+
+The UFO_ENV_EXTRA env variable allows you create multiple environments with of the same services quickly.  More info about is is detailed at [ufo-env-extra]({% link _docs/ufo-env-extra.md %}).  You can also set a current UFO_ENV_EXTRA with the `--env-extra` option.
+
+    ufo current --env-extra 1
+
+## services
+
+The `ufo ships` commands builds one Docker image and deploys them to multiple ECS services, so it usually takes a list of services like so:
+
+    ufo ships demo-web demo-worker demo-clock
+
+This can be shorten with with current also.
+
+    ufo current --services demo-web demo-worker demo-clock
+    ufo ships
+
+<a id="prev" class="btn btn-basic" href="{% link _docs/ufo-env-extra.md %}">Back</a>
+<a id="next" class="btn btn-primary" href="{% link _docs/load-balancer.md %}">Next Step</a>
+<p class="keyboard-tip">Pro tip: Use the <- and -> arrow keys to move back and forward.</p>

data/docs/_docs/ufo-env-extra.md

@@ -0,0 +1,21 @@
+---
+title: UFO_ENV_EXTRA
+---
+
+Ufo has an concept of extra environments. This is controlled by the `UFO_ENV_EXTRA` variable.  By setting `UFO_ENV_EXTRA` you can create additional identical ECS services or environments.
+
+    ufo ship demo-web # creates a demo-web ecs service
+    UFO_ENV_EXTRA=2 ufo ship demo-web # creates a demo-web-2 ecs service
+
+The `UFO_ENV_EXTRA` can also be set with `ufo current` so you do not have to type it over.
+
+    ufo current --env-extra 1
+
+The precedence:
+
+1. UFO_ENV_EXTRA - takes highest precedence
+2. `.ufo/current` env-extra setting - takes lower precedence
+
+<a id="prev" class="btn btn-basic" href="{% link _docs/ufo-env.md %}">Back</a>
+<a id="next" class="btn btn-primary" href="{% link _docs/ufo-current.md %}">Next Step</a>
+<p class="keyboard-tip">Pro tip: Use the <- and -> arrow keys to move back and forward.</p>

data/docs/_docs/ufo-env.md

@@ -8,24 +8,17 @@ Ufo's behavior is controlled by the `UFO_ENV` environment variable.  For example
 
 The `UFO_ENV` can be set in several ways:
 
-1. At the CLI command invocation - This takes the highest precedence.
-2. Exported as an environment variable to your shell - This takes the second highest precedence.
-3. From the `aws_profiles` setting in your `settings.yml` file - This takes the lowest precedence.
-
-## At the CLI Command
-
-```sh
-ufo ship hi-web --cluster production
-```
+1. Exported as an environment variable to your shell - This takes the second highest precedence.
+2. From the `aws_profiles` setting in your `settings.yml` file - This takes the lowest precedence.
 
 ## As an environment variable
 
 ```sh
 export UFO_ENV=production
-ufo ship hi-web
+ufo ship demo-web
 ```
 
-Most people will set `UFO_ENV` in their `~/.profile`.
+You can set `UFO_ENV` in your `~/.profile`.
 
 ## In .ufo/settings.yml
 
@@ -51,6 +44,6 @@ AWS_PROFILE=whatever => UFO_ENV=development # since there are no profiles that m
 
 Notice how `AWS_PROFILE=whatever` results in `UFO_ENV=development`.  This is because there are no matching aws_profiles in the `settings.yml`.  More info on settings is available at [settings]({% link _docs/settings.md %}).
 
-<a id="prev" class="btn btn-basic" href="{% link _docs/params.md %}">Back</a>
-<a id="next" class="btn btn-primary" href="{% link _docs/variables.md %}">Next Step</a>
+<a id="prev" class="btn btn-basic" href="{% link _docs/fargate.md %}">Back</a>
+<a id="next" class="btn btn-primary" href="{% link _docs/ufo-env-extra.md %}">Next Step</a>
 <p class="keyboard-tip">Pro tip: Use the <- and -> arrow keys to move back and forward.</p>