kubes 0.3.5 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d239ce306b5a9eea427cab3ec5ca5f753f0eae3d1822fce65017c23172779562
-  data.tar.gz: 3d97c8d85e6f5bfd02babaf14140f186ebd22c3981fa8eed76ddcdbe7f24958d
+  metadata.gz: 3d309f1eb882767efd06378aa5bff9fbe8e162db4ebcd19b9ffec2637929d8b0
+  data.tar.gz: a60c4ae73920a38cda6780f435475922f318409e34aed8dec827df0b8483d6c5
 SHA512:
-  metadata.gz: 74b0ad9bc27e15f1b8742d26f6b2c09e11e990a69623a7e0b54d12565dc08e3dec5d0c640bfd4f5457aa09f0069c0010a78d39dedc18bd9a2223ebdb34be9c31
-  data.tar.gz: 7f3508f0d3650677a48f1f0069f71b1801ddd0a760f052f725a81f564fd144b6eecbd8c08e79fd2e9ec571a0ada2308d4f84bdfbc6971f66a80a20eec8ffbaae
+  metadata.gz: 600df214d8b09d66bbea43b3114dc8dd3b41011025e76e2741ce2a076fa4af1ab8f07b68e54f1aeaaa72d166a1c9c2970c34f22f314b14b99384c00d8818aee4
+  data.tar.gz: 491bf32c8f78ce324aa500d57976345e28696d2fa483b6c8671d92c62191a3c84ffe11048b743251903c4b9b2ff1a0dc7c92b86211b9b909f8fcb5d813c79b7a

data/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 This project *loosely tries* to adhere to [Semantic Versioning](http://semver.org/), even before v1.0.
 
+## [0.4.0]
+- #26 features: kubes vs kubectl hooks, prune, etc
+- hooks: kubes, kubectl, docker breaking changes.
+- hooks now in the .kubes/config/hooks folder.
+- hook for kubectl supports `on` option for more control over when to run hook.
+- generalize hasher
+- auto prune hashed resources like ConfigMap and Secret
+- kubes prune command for manual running
+- support .yml extension also
+- renamed exec `--name` to `--deployment` option.
+- add `--pod` option to `exec` and `logs` command.
+- fix md5 hash for multiple types within envFrom
+- add skip config option
+
 ## [0.3.5]
 - #25 small fixes: show pod and fetch items nil
 

data/README.md

@@ -1,3 +1,7 @@
+<div align="center">
+  <a href="https://kubes.guru"><img src="https://img.boltops.com/boltops/logos/kubes-black-v1.png" /></a>
+</div>
+
 # Kubes
 
 [![Gem Version](https://badge.fury.io/rb/kubes.png)](http://badge.fury.io/rb/kubes)
@@ -37,12 +41,9 @@ In fact, you can use Kubes to build the files first, and then run `kubectl` dire
     kubes docker push
     kubes compile  # compiles the .kubes/resources files to .kubes/output
 
-Now, use `kubectl` directly. This will apply all the files:
-
-    kubectl apply --recursive -f .kubes/output
-
-You can also selectively apply specific files:
+Now, use `kubectl` directly in the proper order:
 
+    kubectl apply -f .kubes/output/shared/namespace.yaml
     kubectl apply -f .kubes/output/web/deployment.yaml
     kubectl apply -f .kubes/output/web/service.yaml
 

data/docs/_docs/config/args.md

@@ -0,0 +1,10 @@
+---
+title: Args
+---
+
+Kubes supports customizing the args passed to the `docker` and `kubectl` commands:
+
+{% assign docs = site.docs | where: "categories","args" %}
+{% for doc in docs -%}
+* [{{ doc.title }}]({{ doc.url }})
+{% endfor %}

data/docs/_docs/config/args/docker.md

@@ -0,0 +1,19 @@
+---
+title: Docker Args
+nav_text: Docker
+categories: args
+---
+
+Here are some examples of customizing the docker args.
+
+.kubes/config/args/docker.rb
+
+```ruby
+command("build",
+  args: ["--quiet"],
+)
+
+command("push",
+  args: ["--disable-content-trust"],
+)
+```

data/docs/_docs/config/{kubectl/args.md → args/kubectl.md}

@@ -1,5 +1,7 @@
 ---
 title: Kubectl Args
+nav_text: Kubectl
+categories: args
 ---
 
 Here are some examples of customizing the kubectl args.

data/docs/_docs/config/docker.md

@@ -26,45 +26,9 @@ Also, kubes apply another way to skip the docker build:
 
     kubes apply web
 
-## Customizing Args
+## Customizing Args and Hooks
 
-Here are some examples of customizing the docker args.
+See:
 
-.kubes/config/docker/args.rb
-
-```ruby
-command("build",
-  args: ["--quiet"],
-)
-
-command("push",
-  args: ["--disable-content-trust"],
-)
-```
-
-## Hooks
-
-Here are some examples of running custom hooks before and after the docker commands.
-
-.kubes/config/docker/hooks.rb
-
-```ruby
-before("build",
-  execute: "echo 'docker build before hook'",
-)
-
-after("push",
-  execute: "echo 'docker push before hook'",
-)
-```
-
-### exit on fail
-
-By default, if the hook commands fail, then terraspace will exit with the original hook error code.  You can change this behavior with the `exit_on_fail` option.
-
-```ruby
-before("build"
-  execute: "/command/will/fail/but/will/continue",
-  exit_on_fail: false,
-)
-```
+* [Docker Args Docs]({% link _docs/config/args/docker.md %})
+* [Docker Hooks Docs]({% link _docs/config/hooks/docker.md %})

data/docs/_docs/config/hooks.md

@@ -0,0 +1,10 @@
+---
+title: Hooks
+---
+
+Kubes supports a variety of hooks. They can be used to customize and finely control the kubes deploy process.
+
+{% assign docs = site.docs | where: "categories","hooks" %}
+{% for doc in docs -%}
+* [{{ doc.title }}]({{ doc.url }})
+{% endfor %}

data/docs/_docs/config/hooks/docker.md

@@ -0,0 +1,70 @@
+---
+title: Docker Hooks
+nav_text: Docker
+categories: hooks
+---
+
+Here are some examples of running custom hooks before and after the docker commands.
+
+## Build Hooks
+
+.kubes/config/hooks/docker.rb
+
+```ruby
+before("build",
+  execute: "echo 'docker build before hook'",
+)
+
+after("build",
+  execute: "echo 'docker build after hook'",
+)
+```
+
+Results in:
+
+    $ kubes docker build
+    Running docker before build hook.
+    => echo 'docker build before hook'
+    docker build before hook
+    => docker build -t gcr.io/tung-275700/demo:kubes-2020-10-10T20-06-28-2e80bf4 -f Dockerfile .
+    Running docker after build hook.
+    => echo 'docker build after hook'
+    docker build after hook
+    $
+
+## Push Hooks
+
+```ruby
+before("push",
+  execute: "echo 'docker push before hook'",
+)
+
+after("push",
+  execute: "echo 'docker push after hook'",
+)
+```
+
+Results in:
+
+    $ kubes docker push
+    Running docker before push hook.
+    => echo 'docker push before hook'
+    docker push before hook
+    => docker push gcr.io/tung-275700/demo:kubes-2020-10-10T20-06-28-2e80bf4
+    Running docker after push hook.
+    => echo 'docker push after hook'
+    docker push after hook
+    $
+
+## exit_on_fail option
+
+By default, if the hook commands fail, then terraspace will exit with the original hook error code.  You can change this behavior with the `exit_on_fail` option.
+
+```ruby
+before("build"
+  execute: "/command/will/fail/but/will/continue",
+  exit_on_fail: false,
+)
+```
+
+{% include config/hooks/options.md command="docker" %}

data/docs/_docs/config/hooks/kubectl.md

@@ -0,0 +1,83 @@
+---
+title: Kubectl Hooks
+nav_text: Kubectl
+categories: hooks
+---
+
+You can use hooks to run scripts at any part of the `kubectl` commands. Here's an example of running a script before and after the `kubectl apply` command for the `web/deployment` resource.
+
+.kubes/config/hooks/kubectl.rb
+
+```ruby
+before("apply",
+  on: "web/deployment",
+  execute: "echo 'before apply hook test'",
+)
+
+after("delete",
+  on: "web/deployment",
+  execute: "echo 'after delete hook test'",
+)
+```
+
+## on option
+
+The `on` option is important. If it is not set, then the hook script will run on every `kubectl` command. So given this hook definition:
+
+```ruby
+before("apply",
+  # Note how the on option is not set
+  execute: "echo 'before apply hook test'",
+)
+```
+
+With these resource definition files:
+
+    .kubes/resources/shared/namespace.yaml
+    .kubes/resources/web/deployment.yaml
+    .kubes/resources/web/web.yaml
+
+The hook script will run **3** times.
+
+    $ kubes apply
+    # before apply hook test <= HERE 1
+    => kubectl apply -f .kubes/output/shared/namespace.yaml
+    # before apply hook test <= HERE 2
+    => kubectl apply -f .kubes/output/web/service.yaml
+    # before apply hook test <= HERE 3
+    => kubectl apply -f .kubes/output/web/deployment.yaml
+    $
+
+This is probably not what you want.  So it is important to use the `on` option to scope when to run your hook like so:
+
+```ruby
+before("apply",
+  on: "web/deployment",
+  execute: "echo 'before apply hook test'",
+)
+```
+
+The hook script will run **1** time for the `.kubes/resources/web/deployment.yaml`:
+
+    $ kubes apply
+    => kubectl apply -f .kubes/output/shared/namespace.yaml
+    => kubectl apply -f .kubes/output/web/service.yaml
+    # before apply hook test <= HERE
+    => kubectl apply -f .kubes/output/web/deployment.yaml
+    $
+
+The `on` option is used to match the path the gets applied: .kubes/resources/**web/deployment**.yaml
+
+## exit on fail
+
+By default, if the hook commands fail, then terraspace will exit with the original hook error code.  You can change this behavior with the `exit_on_fail` option.
+
+```ruby
+before("apply"
+  on: "web/deployment",
+  execute: "/command/will/fail/but/will/continue",
+  exit_on_fail: false,
+)
+```
+
+{% include config/hooks/options.md command="kubectl" %}

data/docs/_docs/config/hooks/kubes.md

@@ -0,0 +1,67 @@
+---
+title: Kubes Hooks
+nav_text: Kubes
+categories: hooks
+---
+
+You can use hooks to run scripts at specific steps of the `kubes deploy` lifecycle.
+
+## Lifecycle Hooks
+
+Hook | Description
+---|---
+compile | When kubes compiles the `.kubes/resources` to `.kubes/output`.
+apply | When kubes runs all the `kubectl apply` commands.
+delete | When kubes runs all the `kubectl delete` commands.
+
+## Lifecycle At Kubes Level
+
+These lifecycle points occur at a higher-level than the `kubectl` commands. Here's an example to help explain:
+
+    $ kubes apply
+    => kubectl apply -f .kubes/output/shared/namespace.yaml
+    => kubectl apply -f .kubes/output/web/service.yaml
+    => kubectl apply -f .kubes/output/web/deployment.yaml
+    $
+
+Kubes calls out to `kubectl apply` 3 times for each resource kind.
+
+The kubes hooks run before and after **all** the `kubectl apply` commands. So the hook only runs once.
+
+    $ kubes apply
+    # kubes apply before hook <= HERE
+    => kubectl apply -f .kubes/output/shared/namespace.yaml
+    => kubectl apply -f .kubes/output/web/service.yaml
+    => kubectl apply -f .kubes/output/web/deployment.yaml
+    # kubes apply after hook  <= HERE
+    $
+
+## Example
+
+.kubes/config/hooks/kubes.rb
+
+```ruby
+before("apply",
+  execute: "echo 'kubes before apply hook'",
+)
+
+after("apply",
+  execute: "echo 'kubes after apply hook'",
+)
+```
+
+Example results:
+
+    $ kubes apply
+    Running kubes before apply hook.
+    => echo 'kubes before apply hook'
+    kubes before apply hook
+    => kubectl apply -f .kubes/output/shared/namespace.yaml
+    => kubectl apply -f .kubes/output/web/service.yaml
+    => kubectl apply -f .kubes/output/web/deployment.yaml
+    Running kubes after apply hook.
+    => echo 'kubes after apply hook'
+    kubes after apply hook
+    $
+
+{% include config/hooks/options.md command="kubes" %}

data/docs/_docs/config/hooks/ruby.md

@@ -0,0 +1,74 @@
+---
+title: Ruby Hooks
+nav_text: Ruby
+categories: hooks
+---
+
+The hook `execute` option can also be provided Ruby code instead of a string.  Here's how it works:
+
+1. When the execute option is a String: Kubes will shell out and run it as a script.
+2. When the execute option is a Ruby object: Kubes will perform the `call` method on the object or class.
+
+## Ruby Class
+
+When the Ruby object is a class with an instance method `call`, Kubes creates a new instance of the class and runs its `call` method.  Example:
+
+.kubes/config/hooks/kubes.rb
+
+```ruby
+class EnvExporter
+  def call
+    ENV['SECRET_FOO'] = Base64.encode64("hi").strip
+  end
+end
+
+before("compile",
+  execute: EnvExporter,
+)
+```
+
+Kubes will do something like this:
+
+```ruby
+EnvExporter.new.call
+```
+
+The example sets the `SECRET_FOO` environment variable. It is then available from ERB in the kubes resource files. For example:
+
+.kubes/resources/shared/secret.yaml
+
+```yaml
+metadata:
+  namespace: garden
+  name: demo-secret
+  labels:
+    app: garden
+apiVersion: v1
+kind: Secret
+data:
+  foo: <%= ENV['SECRET_FOO']
+```
+
+## Ruby Object
+
+When the Ruby object, Kubes expects it to have a `call` method and will run it.  Example:
+
+.kubes/config/hooks/kubes.rb
+
+```ruby
+before("compile",
+  execute: lambda { ENV['SECRET_FOO'] = Base64.encode64("hi2").strip }
+)
+```
+
+Kubes will do something like this:
+
+```ruby
+@hook[:execute].call
+```
+
+## Process Context
+
+The context in which the hook runs is worth highlighting. When the `execute` option is a String, Kubes runs the script in a **new** child process. This the script is an independent process, and whatever is done to its environment is segregated.
+
+When the `execute` option a Ruby object, then Kubes runs the hook within the **same** process. It means the hook can affect the **same** environment. IE: Setting environment variables.