
![macOS Monterey beta](monterey.png)

Apple is running their annual developer conference WWDC this week and unveiled the 18th major version of macOS – [macOS Monterey](https://www.apple.com/macos/monterey-preview/). It comes with many neat features, but those are not the topic of this post.

The topic of this post is: "How to get Homebrew to work on macOS Monterey Preview."

> What Does Homebrew Do?
>
> Homebrew installs the stuff you need that Apple didn't.

Following instructions will guide you through the process that allows you to use Homebrew Bottles created for macOS Big Sur on macOS Monterey Preview.

#### Update Homebrew

```bash
% brew update
```

#### Try to upgrade...

```bash
% brew upgrade
Warning: You are using macOS 12.
We do not provide support for this pre-release version.
You will encounter build failures with some formulae.
Please create pull requests instead of asking for help on Homebrew's GitHub,
Twitter or any other official channels. You are responsible for resolving
any issues you experience while you are running this
pre-release version.
```

No luck – the newly released macOS is not supported :´(

Fortunately, the solution to this problem is simple!

#### Fool the Homebrew to believe that we are running macOS Big Sur by modifying `brew.sh`

Edit the line `337` on `brew.sh`. Replace the variable `HOMEBREW_MACOS_VERSION` value with a static value, e.g. `"11.5"`, which is the latest minor version of macOS Big Sur.

On Apple Silicon based Mac you can find `brew.sh` from `/opt/homebrew/Library/Homebrew` folder, and Intel Mac `/usr/local/Homebrew/Library/Homebrew` folder.

#### Diff after the modification

After you have saved the changes to `brew.sh` the git diff should look like this:

```diff
% git diff
diff --git a/Library/Homebrew/brew.sh b/Library/Homebrew/brew.sh
index e2875794a..fc0b054c3 100644
--- a/Library/Homebrew/brew.sh
+++ b/Library/Homebrew/brew.sh
@@ -334,7 +334,7 @@ then
   HOMEBREW_PRODUCT="Homebrew"
   HOMEBREW_SYSTEM="Macintosh"
   [[ "${HOMEBREW_PROCESSOR}" = "x86_64" ]] && HOMEBREW_PROCESSOR="Intel"
-  HOMEBREW_MACOS_VERSION="$(/usr/bin/sw_vers -productVersion)"
+  HOMEBREW_MACOS_VERSION="11.5" #"$(/usr/bin/sw_vers -productVersion)"
   # Don't change this from Mac OS X to match what macOS itself does in Safari on 10.12
   HOMEBREW_OS_USER_AGENT_VERSION="Mac OS X ${HOMEBREW_MACOS_VERSION}"
```

#### Disable Homebrew auto-update

By default, Homebrew auto-updates itself, which means that our changes will be overwritten on every update. To prevent this to happen, add the following:

```bash
# disable homebrew self-update
export HOMEBREW_NO_AUTO_UPDATE=1
```

into your `~/.zshrc` or `~/.bashrc`, and source it to make the change active.

#### Run Homebrew upgrade

```bash
brew upgrade
```

See? – No errors.

#### How about Homebrew config?

```bash
% brew config
HOMEBREW_VERSION: 3.1.11-dirty
ORIGIN: https://github.com/Homebrew/brew
HEAD: 9657303ed2c484a4bd8f7527706940f9e4d43354
Last commit: 2 days ago
Core tap ORIGIN: https://github.com/Homebrew/homebrew-core
Core tap HEAD: 1a1121be16d84fcd03ab06e9a88614b4ff1bb365
Core tap last commit: 22 minutes ago
Core tap branch: master
HOMEBREW_PREFIX: /usr/local
HOMEBREW_CASK_OPTS: []
HOMEBREW_MAKE_JOBS: 16
Homebrew Ruby: 2.6.3 => /System/Library/Frameworks/Ruby.framework/Versions/2.6/usr/bin/ruby
CPU: 16-core 64-bit kabylake
Clang: 12.0.5 build 1205
Git: 2.32.0 => /usr/local/bin/git
Curl: 7.76.0 => /usr/bin/curl
macOS: 11.5-x86_64
CLT: 12.0.0.32.29
Xcode: 12.5
```

As we can see, Homebrew thinks that we are still on macOS Big Sur :)

#### Try to reinstall a package

```bash
% brew reinstall gh
==> Downloading https://ghcr.io/v2/homebrew/core/gh/manifests/1.11.0
Already downloaded: /Users/nikovirtala/Library/Caches/Homebrew/downloads/ddad4ddc988804cf6037325a229259e1d5267e9203e69cf901f3e97c93395f7a--gh-1.11.0.bottle_manifest.json
==> Downloading https://ghcr.io/v2/homebrew/core/gh/blobs/sha256:34313bfaca6995d40836da15f3c1cf7579689f5ac1bdcf3e2e4e50c
Already downloaded: /Users/nikovirtala/Library/Caches/Homebrew/downloads/1eb3f40cf6fa82560f54b235fdedb761b36170a5b9d5c26b58be3d3b9afcb89b--gh--1.11.0.big_sur.bottle.tar.gz
==> Reinstalling gh
==> Pouring gh--1.11.0.big_sur.bottle.tar.gz
==> Caveats
zsh completions have been installed to:
  /usr/local/share/zsh/site-functions
==> Summary
🍺  /usr/local/Cellar/gh/1.11.0: 89 files, 28.6MB
```

That seems to be working too.

#### How about the future?

Naturally, tools like Homebrew don't support new operating system versions on the day they're released to the developer preview, but eventually, the support will follow – until then: happy hacking!


How to get Homebrew to work on macOS Monterey Preview?


## Opening Remarks

This is a continuously updated list of articles, blog posts, tweets, videos, books, albums, pictures, you name it — random things that I've found somehow thought-provoking or even world-shaking lately.

The list is one window to my soul landscape, and maybe one day, we can see how my world has changed over time - or then not. 😄

The list runs in reverse chronological order; the last item added is found first in the list.

## The List

[What Silicon Valley "Gets" about Software Engineers that Traditional Companies Do Not](https://blog.pragmaticengineer.com/what-silicon-valley-gets-right-on-software-engineers/)

> As a software engineer, pleasant places to work at is where you are a problem solver, not a factory worker. Which one are you today? – Gergely Orosz

[Jeff Bezos Says It Will Always Be "Day 1" at Amazon](https://www.fool.com/investing/2017/04/13/jeff-bezos-says-it-will-always-be-day-1-at-amazon.aspx)

> Day 2 is stasis. Followed by irrelevance. Followed by excruciating, painful decline. Followed by death. And that is why it is always Day 1. – Jeff Bezos

[If Management Isn’t A Promotion, Then Engineering Isn’t A Demotion](https://charity.wtf/2020/09/06/if-management-isnt-a-promotion-then-engineering-isnt-a-demotion/)

> We need to see the work that engineers, managers, directors, VPs, and CxOs do as equally valuable and equally capable of prestige. We need to flip the org chart upside down, and treat “management” roles like support systems they should be. – Charity Majors

[Why Digital Organizations Are Principles-Based](https://aws.amazon.com/blogs/enterprise-strategy/why-digital-organizations-are-principles-based/)

> To gain the maximum speed, you need your autonomous teams to be able to make as many decisions as possible themselves. ― Mark Schwartz

[Organization Observation](https://twitter.com/johncutlefish/status/1296316581153091585?s=20)

> People tend to resist changes in structure that counteract their chosen method of influence. ― John Cutler

[The Future of Ops Jobs](https://acloudguru.com/blog/engineering/the-future-of-ops-jobs)

> Ops is everybody's job now. ― Charity Majors

[Your Code May Be Elegant](https://omniti.com/seeds/your-code-may-be-elegant.html)

> Your code may be elegant, by mine f\*\*\*ing works. ― Leon Fayer

[On Being a Senior Engineer](https://www.kitchensoap.com/2012/10/25/on-being-a-senior-engineer/)

> I expect a "senior" engineer to be a mature engineer. ― John Allspaw

[But Why Is It Working?](https://cutlefish.substack.com/p/tbm-3353-but-why-is-it-working)

> Unhappy teams and organizations are often very similar, while happy/successful teams and organizations can be quite different! ― John Cutler


The Ever-updating Reading List


![the key](key.jpg)

> What I cannot create, I do not understand. ― Richard P. Feynman

As multi-account AWS architectures have become more common, there has also been a need to implement centralized user and access management. The AWS solution to this problem is AWS SSO, which is indeed a neat solution, but ...

Many popular developer tools, including AWS' own CDK (Cloud Development Kit) and Amplify, do not support it yet, as we can find from the GitHub issues:

- [AWS SSO Named Profiles Support](https://github.com/aws/aws-cdk/issues/5455)
- [Problem using CLI via AWS SSO](https://github.com/aws-amplify/amplify-cli/issues/4488)

As usual, the best answer to these problems can be found on Twitter, so also this time. [I complained about the issue](https://twitter.com/nikovirtala/status/1304308556083200006), and very soon, I had the best solution so far in my hands!

[Ben Kehoe](https://twitter.com/ben11kehoe) has written two nice helper tools to go around the problem:

- [benkehoe/aws-sso-credential-process](https://github.com/benkehoe/aws-sso-credential-process)
- [benkehoe/aws-export-credentials](https://github.com/benkehoe/aws-export-credentials)

And [Jared Short](https://twitter.com/ShortJared) came up with a little helper function, which will nicely tie the whole process together.

So, what do I need to do?

1. Install the two tools; [aws-sso-credential-process](https://github.com/benkehoe/aws-sso-credential-process) and [aws-export-credentials](https://github.com/benkehoe/aws-export-credentials)

2. Place following to your `.bashrc`, `.zshrc` or similar: _– Don't forget to replace the start URL and region values._

```bash
export AWS_CONFIGURE_SSO_DEFAULT_SSO_START_URL=https://<your-sso>.awsapps.com/start
export AWS_CONFIGURE_SSO_DEFAULT_SSO_REGION=<your-default-region>

sso(){
  unset AWS_PROFILE
  export AWS_PROFILE=$1
  aws sts get-caller-identity &> /dev/null \
  || aws sso login \
  || (unset AWS_PROFILE && aws-configure-sso-profile --profile)
  eval $(aws-export-credentials --env-export)
}
```

3. Source your profile, run `sso`, and off you go! – The helper tools will configure your shell with credentials that most of the tools can understand, even they wouldn't support AWS SSO yet.


How To Use AWS Developer Tools With AWS SSO?


Sometimes it's nice to do something, maybe a little indecisive, just because it's possible. That's the subject of this blog.

It is just two days ago when I asked on Twitter:

> Has anyone deployed their self-hosted #GitHub Actions runners to #AWS #Fargate? – [@nikovirtala](https://twitter.com/nikovirtala/status/1252630501258661894?s=20)

Apparently, no one did, since also Google didn't provide me any hits. 🤷

So, what was all this buzz about and what I actually wanted to achieve?

> [GitHub Actions](https://github.com/features/actions) is a software workflow automation tool with CI/CD capability from GitHub. In November 2019, GitHub open-sourced the [runner](https://github.com/actions/runner) component and added [support to run workflows on self-hosted machines](https://github.blog/changelog/2019-11-05-github-actions-self-hosted-runners/).

> [AWS Fargate](https://aws.amazon.com/fargate/), on the other hand, is a serverless compute engine for containers and one of the best computing inventions of this decade.

**I want to use AWS Fargate to host my GitHub Actions runners!**

Since both technologies are familiar to me, I decided to pull strings together. As an exception to my regular routines, I chose to use [AWS Cloud Development Kit](https://github.com/aws/aws-cdk) as a deployment tool instead of a safe and sound Terraform.

After a few hours of work, I came up with this: a fully functional example of executing self-hosted GitHub Actions runner on AWS Fargate! https://github.com/nikovirtala/github-actions-runner

It’s still raw, but most importantly, it proves the concept works! If you have any questions or comments, poke me on [Twitter](https://twitter.com/nikovirtala) or [GitHub](https://github.com/nikovirtala), I'm all ears. :)

Ps. I right before finishing this post, I noticed that yesterday we also got support for [Organization level self-hosted runners](https://github.blog/changelog/2020-04-22-github-actions-organization-level-self-hosted-runners/). It only means that my newly created side project just got a new feature too! 🤓


GitHub Actions Runner on AWS Fargate


This blog is based on [Gatsby](https://www.gatsbyjs.org) and initiated from [Gatsby's blog starter](https://www.gatsbyjs.org/starters/gatsbyjs/gatsby-starter-blog/); boilerplate for a full-featured blog. While it provides a lot of useful features for a blog, it also leaves plenty of room for customization, which is something I like.

In this post, I go through how to add functionality to share posts into social media platforms like Twitter and Linked In.

Since I know that Gatsby has a plugin library, my first thought was to find a suitable plugin from there, but I couldn't find any. It is interesting because social media sharing is a pretty basic functionality for any blog, in my opinion. It started to seem that this but would not let me off easy. – since one of the primary purposes of this blog is to learn different things, it's okay.

After a little search in Google, GitHub and npmjs.com, I found packages called [`react-share`](https://www.npmjs.com/package/react-share) and [`react-icons`](https://www.npmjs.com/package/react-icons), those looked sufficient for my purpose. _– I based my decision to use these packages out of dozens of other packages on their popularity and the fact that there were releases made recently._

Now I only needed to find my way over creating and using a React component.

//TODO: Learn more about [React components](https://reactjs.org/tutorial/tutorial.html).

Okay. First of all, let's install the packages and their dependencies by:

```bash
yarn add react-share react-icons
```

Then create new React component under `src/components/share.js`:

```javascript
/**
 * A component to share pages to social media platforms.
 */

import React from "react";
import PropTypes from "prop-types";

import { TwitterShareButton, LinkedinShareButton } from "react-share";

import { IconContext } from "react-icons";
import { FaTwitter, FaLinkedin } from "react-icons/fa";

const SocialShare = (props) => {
  const { url, title } = props;

  const shareBlockProps = {
    url: url,
    title: title,
  };

  return (
    <IconContext.Provider
      value={{
        size: "1.5rem",
        className: "share",
        style: { marginRight: "0.5rem", marginBottom: "1.0rem" },
      }}
    >
      <div>
        <TwitterShareButton {...shareBlockProps}>
          <FaTwitter />
        </TwitterShareButton>
        <LinkedinShareButton {...shareBlockProps}>
          <FaLinkedin />
        </LinkedinShareButton>
      </div>
    </IconContext.Provider>
  );
};

SocialShare.propTypes = {
  url: PropTypes.string,
  title: PropTypes.string,
};

SocialShare.defaultProps = {
  url: "https://cloudgardener.dev/",
  title: "Post with no title.",
};

export default SocialShare;
```

To enable this newly created component for blog posts, we need to adjust the post template in `src/templates/blog-post.js`.

Let's start by importing the component:

```javascript
import SocialShare from "../components/share";
```

Then gather information needed from page data.

The `SocialShare` component currently takes in two properties, `url` and `title`, and to be able to fill those, we need to adjust the `pageQuery` by adding `siteUrl` and `fields { slug }` into it:

```javascript
export const pageQuery = graphql`
  query BlogPostBySlug($slug: String!) {
    site {
      siteMetadata {
        title
        siteUrl
      }
    }
    markdownRemark(fields: { slug: { eq: $slug } }) {
      id
      excerpt(pruneLength: 160)
      html
      fields {
        slug
      }
      frontmatter {
        title
        date(formatString: "MMMM DD, YYYY")
        description
      }
    }
  }
`;
```

Now we have all the data to define the `postUrl` variable, inside the `render()` block:

```javascript
const postUrl = this.props.data.site.siteMetadata.siteUrl + post.fields.slug;
```

Last but not least we use the `SocialShare` component inside the `return` block, after the post section:

```html
<SocialShare url="{postUrl}" title="{post.frontmatter.title}" />
```

The result looks like this:

![Social Media Sharing](social-media-sharing.png)

Here you can see the complete [`src/templates/blog-post.js`](https://github.com/cloudgardener/blog/blob/master/src/templates/blog-post.js).

That's about it! Now I have a functional social media sharing on my blog. What's next? – Who knows. :)

> "Every day, work to refine the skills you have and to add new tools to your repertoire."
> ― Andrew Hunt, The Pragmatic Programmer: From Journeyman to Master

Sincerely yours, your Cloud Gardener,

/niko


Customizing the Blog - part 1/n - Social Media Sharing


You may have a clue as to what I'm trying to present with this title, but do you want to hear the whole story?

> “Rather than construction, programming is more like gardening—it is more organic than concrete.” — The Pragmatic Programmer: From Journeyman to Master by Andrew Hunt and David Thomas

That is very aptly said and made me smile very broadly. As today's cloud infrastructure is an ever-increasing extent software and code, why can I not adopt this metaphor? — So I did, and this is how I got a new great title and name for this blog.

Ok, I must confess that it is also a little slap on the wrist for all the people taking their titles too seriously. :)

p.s. A new revised 20th Anniversary Edition of The Pragmatic Programmer is now available [here](https://pragprog.com/book/tpp20/the-pragmatic-programmer-20th-anniversary-edition). I'm going to read it, how about you?

Sincerely yours,
your Cloud Gardener,

/niko


What is Cloud Gardener?


> You can’t think yourself out of a writing block; you have to write yourself out of a thinking block. ― John Rogers

A Piece of Blank Paper. It's a title of the very first post on my new personal blog. Now you may only guess what this post is about to deal with. Yes, you could guess right, it touches something we call the writer's block. I'm pretty sure that this post is not going to offer any cure for it, or to provide unambiguous advice to make it any easier, it's more of putting my thoughts about it out.

I must admit that I suffer writer's block a lot, and I think I have been experienced it like... always. On most the days I really don't know how to get started, and it is very likely not due to the lack of ideas or thoughts, but rather the opposite. — I just feel that I cannot find a way to express my views in a simple enough way. Perhaps because I insist on myself too much, but it is an entirely different topic.

The quote, in the beginning, says: "You can’t think yourself out of a writing block; you have to write yourself out of a thinking block." That said, you may understand the purpose of this blog. It's mainly my personal tool for learning to express thoughts in written form. I may repeat myself by saying this, but by being me soon 34 years, I have learned about myself that much that, I know I learn by doing. So, how else I could publish more and become a better writer than by just writing more?

How do I define that better writer I'd like to become? — I think it's relatively easy to identify it based on the context of this blog text: I want to publish more content about topics I'm working with, and I'm interested in. The content may be, e.g. in the form of guidance or opinion, and posted in this blog, Twitter, LinkedIn or company Confluence. The main point here is on getting the words to the paper and published, in a way or another.

I'm also many times talking about sharing information and consume a lot of knowledge shared by various communities, so this exercise is also a little bit of "walk the talk" type of reminder for myself.

Technically this blog is a static web page generated with [Hugo](https://gohugo.io), hosted on [Netlify](https://netlify.com) and it does not collect any kind of statistics or analytics nor have a possibility for commenting or anything else that could take my focus away from the main, producing the content. Since I want this blog to be content focused, I also chose a theme that is visually simple and classy; no eye candy here.

The content of future posts, just like the blog name says, can vary everywhere between life, the universe, and everything, but will most likely mostly focus on topics like containers, cloud, infrastructure as code and continuous delivery. The stuff I am working with a daily basis, and which happens to be also one of my personal interests.

This is the beginning. Nothing can stop me now?

Sincerely yours,

/niko


This is the beginning. Nothing can stop me now?

A Piece of Blank Paper


![](1*I533oGWLyOJ3tVKtCrFRaQ.jpeg)

## What’s the story?

This is a second part on my ‘How do I set up my local Kubernetes environment
today?’ series. On the [first
part](https://medium.com/@nikovirtala/how-do-i-set-up-my-local-kubernetes-environment-today-part-1-2f2d83a9a3e1)
I covered how I am utilizing LinuxKit Kubernetes on my local development
environment. If you haven’t read it yet, I strongly recommend to do it now. — It
gives you the background to this story.

## Code, Build, Push, Deploy, Test, Repeat

Code, build, push, deploy, test and repeat. Do you recognize the pattern? How
many times you repeat it while building an image? — Some may say too many.

What if I tell you that there is a tooling available that helps on this. Tooling
that is not as heavy as full blown CI/CD pipeline but something that covers the
most crucial functionalities of it and is lightweight enough to run on our local
development environment. — Got interested?

## Skaffold

Skaffold is relatively new open source project from [Google Could
Platform](https://cloud.google.com/) team and this how they describe their
project on their [GitHub page](https://github.com/GoogleCloudPlatform/skaffold):

> Skaffold is a command line tool that facilitates continuous development for
> Kubernetes applications. You can iterate on your application source code locally
> then deploy to local or remote Kubernetes clusters. Skaffold handles the
> workflow for building, pushing and deploying your application. It can also be
> used in an automated context such as a CI/CD pipeline to leverage the same
> workflow and tooling when moving applications to production.

Sound like we have something in our hands that answers to our demand to automate
parts of our development workflow. So, let’s see how it works in practice.

## Installation

At the moment there is two easy ways to install Skaffold on Linux; download the
latest binary release or build from sources.

## Build from source

As the project is relatively young I like to keep up with the latest changes by
building the skaffold from sources. — This requires installation of `go` (1.10
minimum) , `git` and `make` . So, let’s build the Skaffold!

Start by downloading the latest sources:

```bash
[nikovirtala@thinky ~ ]$ go get -u -d github.com/GoogleCloudPlatform/skaffold
package github.com/GoogleCloudPlatform/skaffold: no Go files in /home/nikovirtala/go/src/github.com/GoogleCloudPlatform/
skaffold
```

enter into the source folder:

```bash
[nikovirtala@thinky ~ ]$ cd $GOPATH/src/github.com/GoogleCloudPlatform/skaffold
```

build it:

```bash
[nikovirtala@thinky skaffold ]$ make install
mkdir -p ./out
GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go install -ldflags " -X github.com/GoogleContainerTools/skaffold/pkg/skaffold/ver
sion.version=v0.4.0 -X github.com/GoogleContainerTools/skaffold/pkg/skaffold/version.buildDate=2018-04-18T15:36:12Z -X g
ithub.com/GoogleContainerTools/skaffold/pkg/skaffold/version.gitCommit=7a89445cc34ee6f243fdf9e039c7d9264fd7cd6a -X githu
b.com/GoogleContainerTools/skaffold/pkg/skaffold/version.gitTreeState=clean " -tags "kqueue container_image_ostree_stub
containers_image_openpgp" github.com/GoogleContainerTools/skaffold/cmd/skaffold
```

and test the installation:

```bash
[nikovirtala@thinky skaffold ]$ which skaffold
/home/nikovirtala/go/bin/skaffold
```

```bash
[nikovirtala@thinky skaffold ]$ skaffold version
v0.4.0
```

OK, now we have `skaffold` installed and we are ready to configure our first
project!

## Binary release

An alternative for building the `skaffold` from sources is to download the
latest binary release. At the point of writing the latest binary release version
is `v0.4.0` and the change log is available
[here](https://github.com/GoogleCloudPlatform/skaffold/blob/master/CHANGELOG.md).

Installing binary release can be done simply by running a following one liner. —
If you already build one from sources, you can skip this step.

```bash
curl -Lo skaffold

&& chmod +x skaffold && sudo mv skaffold /usr/local/bin
```

## Set up your first Skaffold project

Skaffold configuration is defined in `skaffold.yaml`. This YAML file defines how
your container image is built, where it is stored and which resources should be
deployed in to Kubernetes cluster.

To be able to demonstrate how the build, push and deploy automation works with
Skaffold we need a little sample application, its `Dockerfile`, repository on
some image registry where to push the image, Kubernetes resource definitions and
a Kubernetes cluster. — I am going to use the same
[whalesay](https://github.com/nikovirtala/whalesay) application that I used on
[first
part](https://medium.com/@nikovirtala/how-do-i-set-up-my-local-kubernetes-environment-today-part-1-2f2d83a9a3e1/#2aa7)
to demonstrate the service deployment on Kubernetes, my repository is a
`nikovirtala/skaffold-demo` on Docker Hub and my Kubernetes cluster is LinuxKit
Kubernetes Project running on my laptop.

You may consider following definitions as a bare minimum required to run to
continuous deployment with Skaffold. So, this is what I have on my project
folder:

```bash
[nikovirtala@thinky whalesay ]$ ls -1
Dockerfile
kubernetes-whalesay.yml
skaffold.yaml
whalesay.go
```

`whalesay.go` — a little go application to print Moby ASCII and container ID.

```bash
[nikovirtala@thinky whalesay ]$ cat whalesay.go
package main

import (
  "fmt"
  "log"
  "net/http"
  "os"
)

func handler(w http.ResponseWriter, r *http.Request) {
  var name, _ = os.Hostname()

  fmt.Fprintf(w, `<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>nikovirtala/whalesay</title>
</head>
<body>
<pre>
                    ##        .
              ## ## ##       ==
            ## ## ## ##      ===
        /""""""""""""""""\___/ ===
  ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
        \______ o          __/
          \    \        __/
          \____\______/

          |          |
        __ |  __   __ | _  __   _
      /  \| /  \ /   |/  / _\ |
      \__/| \__/ \__ |\_ \__  |

This request was processed by: %s
</pre>
</body>
</html>
`, name)
log.Print("Served request ",r,"\n")
}

func main() {
  log.SetOutput(os.Stderr)
  log.Println("Starting server ...")
  http.HandleFunc("/", handler)
  err := http.ListenAndServe(":80",nil)
  if err != nil {
    log.Fatal("ListenAndServer: ", err)
  }
}
```

`Dockerfile` — This defines the container image to be built.

```bash
[nikovirtala@thinky whalesay ]$ cat Dockerfile
FROM golang:alpine as build

WORKDIR /whalesay
ADD . .
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o whalesay .

FROM alpine:edge
LABEL maintainer "Niko Virtala <niko@nikovirtala.io>"

WORKDIR /
COPY --from=build /whalesay .
EXPOSE 80
ENTRYPOINT ["/whalesay"]
```

`kubernetes-whalesay.yml`— Definition for Kubernetes service deployment and
exposure.

```bash
[nikovirtala@thinky whalesay ]$ cat kubernetes-whalesay.yml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: whalesay
  labels:
    app: whalesay
spec:
  replicas: 3
  selector:
    matchLabels:
      app: whalesay
  template:
    metadata:
      labels:
        app: whalesay
    spec:
      containers:
      - name: whalesay
        image: docker.io/nikovirtala/skaffold-demo
        ports:
        - containerPort: 80

---
apiVersion: v1
kind: Service
metadata:
  name: whalesay
  labels:
    app: whalesay
spec:
  type: NodePort
  ports:
  - port: 80
    nodePort: 30001
    protocol: TCP
  selector:
    app: whalesay
```

`skaffold.yaml` — Skaffold build, push and deploy instructions.

```bash
[nikovirtala@thinky whalesay ]$ cat skaffold.yaml
apiVersion: skaffold/v1alpha2
kind: Config
build:
  artifacts:
  - imageName: docker.io/nikovirtala/skaffold-demo
    workspace: ./
    docker: {}
  local: {}
deploy:
  kubectl:
    manifests:
    - ./kubernetes-whalesay.yml
```

Now we have all necessary configuration defined, so let’s get the party started!

## Start continuous deployment

Just to make this demo clear, let’s make sure that our Kubernetes cluster does
not have any related resources running before we begin:

```bash
[nikovirtala@thinky whalesay ]$ kubectl config current-context
kubernetes-admin@kubernetes
[nikovirtala@thinky whalesay ]$ kubectl get pods
No resources found.
```

Seems we have nothing running, so we are good to begin.

To start continuous deployment run: `skaffold dev` like this:

```bash
[nikovirtala@thinky whalesay ]$ skaffold dev
Starting build...
Sending build context to Docker daemon  108.5kB
Step 1/10 : FROM golang:alpine as build
  ---> 52d894fca6d4
Step 2/10 : WORKDIR /whalesay
  ---> Using cache
  ---> e247af3d14a2
Step 3/10 : ADD . .
  ---> Using cache
  ---> 26f6a12145a9
Step 4/10 : RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o whalesay .
  ---> Using cache
  ---> 117e35c8159a
Step 5/10 : FROM alpine:edge
  ---> 5c4fa780951b
Step 6/10 : LABEL maintainer "Niko Virtala <niko@nikovirtala.io>"
  ---> Using cache
  ---> 6abf21436c87
Step 7/10 : WORKDIR /
  ---> Using cache
  ---> e41edc48d94b
Step 8/10 : COPY --from=build /whalesay .
  ---> Using cache
  ---> 60169baaf4c7
Step 9/10 : EXPOSE 80
  ---> Using cache
  ---> 6ffacee2d0ce
Step 10/10 : ENTRYPOINT ["/whalesay"]
  ---> Using cache
  ---> 7c553383951b
Successfully built 7c553383951b
Successfully tagged bcc16f193f0c7bfc2ebe52e66d34892f:latest
Digest: bcc16f193f0c7bfc2ebe52e66d34892f:latest
Successfully tagged docker.io/nikovirtala/skaffold-demo:7c553383951b0e099e2ea1e81b86bee59e32c249ffb3279701f31dc799f08e0a
The push refers to repository [docker.io/nikovirtala/skaffold-demo]
d18415a0fc1a: Preparing
c9e8b5c053a2: Preparing
d18415a0fc1a: Layer already exists
c9e8b5c053a2: Layer already exists
7c553383951b0e099e2ea1e81b86bee59e32c249ffb3279701f31dc799f08e0a: digest: sha256:e64b03e193ef96d061b9db5f1db5c7b60d55af32d7db5300f2d
a29252913057a size: 739
Build complete in 6.041379946s
Starting deploy...
Deploying ./kubernetes-whalesay.yml...
Deploy complete in 444.734517ms
Watching for changes...
[whalesay-c47584b84-nzzhp whalesay] 2018/04/19 14:48:06 Starting server ...
[whalesay-c47584b84-np4cs whalesay] 2018/04/19 14:48:06 Starting server ...
[whalesay-c47584b84-zk8nn whalesay] 2018/04/19 14:48:07 Starting server ...
```

Quite amazing indeed! So, what really happened here?

1.  Container image was built based on `Dockerfile`
1.  The image was tagged and pushed to repository defined in `skaffold.yaml`
1.  Resources defined in `kubernetes-whalesay.yml` was deployed in to Kubernetes
    cluster
1.  Skaffold is waiting for changes …
1.  Log stream to deployed pods was opened

Can we verify it all somehow? — Yes, we can!

First the container image, we should be able to pull it from registry:

```bash
[nikovirtala@thinky whalesay ]$ docker pull docker.io/nikovirtala/skaffold-demo:7c553383951b0e099e2ea1e81b86bee59e32c249ffb3279701f3
1dc799f08e0a
7c553383951b0e099e2ea1e81b86bee59e32c249ffb3279701f31dc799f08e0a: Pulling from nikovirtala/skaffold-demo
Digest: sha256:e64b03e193ef96d061b9db5f1db5c7b60d55af32d7db5300f2da29252913057a
Status: Downloaded newer image for nikovirtala/skaffold-demo:7c553383951b0e099e2ea1e81b86bee59e32c249ffb3279701f31dc799f08e0a
```

It seems that we can. How about the Kubernetes resources, we should be able to
see those too?

```bash
[nikovirtala@thinky whalesay ]$ kubectl get deployments
NAME       DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
whalesay   3         3         3            3           10m
[nikovirtala@thinky whalesay ]$ kubectl get services
NAME         TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1        <none>        443/TCP        2h
whalesay     NodePort    10.105.164.190   <none>        80:30001/TCP   10m
[nikovirtala@thinky whalesay ]$ kubectl get pods
NAME                       READY     STATUS    RESTARTS   AGE
whalesay-c47584b84-np4cs   1/1       Running   0          10m
whalesay-c47584b84-nzzhp   1/1       Running   0          10m
whalesay-c47584b84-zk8nn   1/1       Running   0          10m
```

As expected the resources we defined are deployed in to our Kubernetes cluster.
So, no magic, just a little automation that makes developer happy.

The voice back of your head may say now: H*ey, that is not continuous!* —Yes, it
is not until we make some change to our code … let me show you a little video:

<span class="figcaption_hack">Skaffold Continuous Deployment Workflow</span>

- On the left pane we have the `skaffold` output.
- On the upper right pane we watch the web page our service produce.
- On the lower right pane we are making changes to our code “on the fly”.

Liked what you just saw? — So did I and Skaffold has became my tool of choice
when developing container images to Kubernetes environment and especially for
the cases where a lots of iterations are needed.

## Conclusion

Skaffold seems to be very powerful and widely configurable continuous deployment
tool; we only scratched the surface and how much we got with just a few lines of
configuration? — A lot, then think what it could do on more complex application
set up. I stand amazed.

## Post Scriptum

This post was a second part of my ‘How do I set up my Kubernetes development
environment today?’ series. On [first
part](https://medium.com/@nikovirtala/how-do-i-set-up-my-local-kubernetes-environment-today-part-1-2f2d83a9a3e1)
we set up a local Kubernetes environment with [LinuxKit Kubernetes
Project](https://github.com/linuxkit/kubernetes) and on this one built up a
continuous deployment workflow with
[Skaffold](https://github.com/GoogleContainerTools/skaffold). In the next part I
am going to build container images without Docker daemon. — See you around!

## To Do

Perhaps I answered to the most fundamental questions about the workflow, there
is always more things to be considered, like:

- How to work with Helm charts?
- How to utilize build cache with LinuxKit Kubernetes; build and deploy container images without pushing them to registry first?


Cloud Gardener