{"id":353,"date":"2018-10-16T10:58:38","date_gmt":"2018-10-16T10:58:38","guid":{"rendered":"https:\/\/www.appservgrid.com\/paw93\/?p=353"},"modified":"2018-10-17T08:27:01","modified_gmt":"2018-10-17T08:27:01","slug":"using-helm-without-tiller-giant-swarm","status":"publish","type":"post","link":"https:\/\/www.appservgrid.com\/paw93\/index.php\/2018\/10\/16\/using-helm-without-tiller-giant-swarm\/","title":{"rendered":"Using Helm without Tiller – Giant Swarm"},"content":{"rendered":"

\"What<\/p>\n

When starting with Kubernetes, learning how to write manifests and bringing them to the apiserver is usually the first step. Most probably kubectl apply is the command for this.<\/p>\n

The nice thing here is that all the things you want to run on the cluster are described precisely and you can easily inspect what will be sent to the apiserver.<\/p>\n

After the joy of understanding how this works, it quickly becomes cumbersome to copy your manifests around and edit the same fields over different files to get a slightly adjusted deployment out.<\/p>\n

The obvious solution to this is templating, and Helm is the most well-known solution in the Kubernetes ecosystem to help out with this. Most how-tos directly advise you to install the clusterside Tiller component and unfortunately this comes with a bit of operational overhead and even more importantly you also need to take care to secure access to Tiller<\/a>, since it is a component running in your cluster with full admin rights.<\/p>\n

If you want to see what actually will be sent to the cluster you can leave out Tiller and use Helm locally just for the templating and using kubectl apply in the end.<\/p>\n

There is no need for Tiller and there are roughly three steps to follow:<\/p>\n

    \n
  1. Fetching the chart templates<\/li>\n
  2. Rendering the template with configurable values<\/li>\n
  3. Applying the result to the cluster<\/li>\n<\/ol>\n

    This way you benefit from the large amount of maintained Charts the community is building, but have all the building blocks of an application in front of you. When keeping them in a git repo it is easy to compare changes from new releases with the current manifests you used to deploy on your cluster. This approach might nowadays be called GitOps<\/a>.<\/p>\n

    A possible directory structure could look like this:<\/p>\n

    kubernetes-deployment\/
    \ncharts\/
    \nvalues\/
    \nmanifests\/<\/p>\n

    For the following steps the helm client needs to be installed<\/a> locally.<\/p>\n

    Fetching the chart templates<\/h2>\n

    To fetch the source code of the charts the url to the repository is needed, also the chart name and the wanted version:<\/p>\n

    helm fetch
    \n–repo https:\/\/kubernetes-charts.storage.googleapis.com
    \n–untar
    \n–untardir .\/charts
    \n–version 5.5.3
    \nprometheus<\/p>\n

    After this the template files can be inspected under .\/charts\/prometheus.<\/p>\n

    Rendering the template with configurable values<\/h2>\n

    The default values.yaml should be copied to a different location for editing so it is not overwritten when updating the chart source.<\/p>\n

    cp .\/charts\/prometheus\/values.yaml
    \n.\/values\/prometheus.yaml<\/p>\n

    The copied prometheus.yaml can now be adjusted as needed. To render the manifests from the template source with the potentially edited values file:<\/p>\n

    helm template
    \n–values .\/values\/prometheus.yaml
    \n–output-dir .\/manifests
    \n.\/charts\/prometheus<\/p>\n

    Applying the result to the cluster<\/h2>\n

    Now the resulting manifests can be thoroughly inspected and finally be applied to the cluster:<\/p>\n

    kubectl apply –recursive –filename .\/manifests\/prometheus<\/p>\n

    Conclusion<\/h2>\n

    With just the standard helm command we can closely check the whole chain from the charts content to the app coming up on our cluster. To make these steps even more easy I have put them in a simple plugin for helm and named it nomagic<\/a>.<\/p>\n

    Caveats<\/h2>\n

    There might be dragons. It might be, that an application needs different kinds of resources that depend on each other. For example applying a Deployment that references a ServiceAccount won\u2019t work until that is present. As a workaround the filename for the ServiceAccounts manifest unter manifests\/ could be prefixed with 1- since kubectl apply progresses over files in alphabetical order. This is not needed in setups with Tiller, so it is usually not considered in the upstream charts. Alternatively run kubectl apply twice to create all independent objects in the first run. The dependent ones will show up after the second run.<\/p>\n

    And obviously you lose features that Tiller itself provides. According to the Helm 3 Design Proposal<\/a> these will be provided in the long run by the Helm client itself and an optional Helm controller<\/a>. With the release of Helm 3 the nomagic plugin won\u2019t be needed, but it also might not function any more since plugins need to be implemented in Lua<\/a>. So grab it while it\u2019s useful!<\/p>\n

    Please share your thoughts about this, other caveats or ideas to improve.<\/p>\n

    And as always: If you\u2019re interested in how Giant Swarm can run your Kubernetes on-prem or in the cloud contact us today to get started.<\/p>\n

    Further Reading<\/h2>\n