Skip to main content

Quay: Introducing an Application Registry for Kubernetes

When we started Quay, we wanted to build an image registry that not only allowed you to manage your container images, but do so securely and reliably. Over the past few months we have noticed an accelerated interest in Quay and containers in general. One of the main forces driving this growth is the adoption of container orchestration and in particular, Kubernetes. And with the introduction of a new platform came a new set of challenges around deploying ever increasingly complex applications.

A complete application is rarely defined as a single container image and their deployment is typically dependent on other services. Further, there are configuration details that are necessary to get a complete application up and running. Ultimately, every application can be boiled down to the result of code and configuration. In the case of Kubernetes, this equates to the set of container images and the Kubernetes object manifests that reference them.

The problem with most registries is that they typically deal with a single object: the container image. Traditionally, registries have not been extended into managing what most users are actually deploying: complete applications. Managing applications isn’t quite the same as individual container images; understanding the dependencies and configuration associated with specific releases of an application is a brand new problem for registries to solve, in addition to the new workflows that users will demand.

Kubernetes Application Registry

Over the past few months, the Quay team has been laying the foundation for the first Kubernetes Application Registry. On the server side, we’ve added an experimental registry API to Quay and a minimal UI enabling the storage, discovery, and management of complete applications. On the client side, we’ve created a registry plugin for Helm, the Kubernetes package manager, that brings all of these features to the ecosystem of Helm applications, known as Charts. One of the most interesting new features introduced to both Quay and Helm is the concept of customizable release channels, much like how CoreOS ships Alpha, Beta, and Stable channels for Container Linux releases. All of this is done through a community-driven API specification, called App Registry, that enables Kubernetes ecosystem to develop more sophisticated tools and more reliable deployment pipelines. This ultimately delivers a Kubernetes Application Registry.

Using Helm to deploy an application

We invite you to use this experimental feature today in Quay.io and then deploy your applications using Helm. Below is a guide to get that up and running.

Install the Helm Registry Plugin

First, Install the latest Helm release. If you are an OSX user, quickstart with brew: brew install kubernetes-helm Next download and install the registry plugin for Helm.

OSX

$ curl -L https://github.com/app-registry/helm-plugin/releases/download/v0.3.7/registry-helm-plugin-v0.3.7-dev-osx-x64.tar.gz -o registry-helm-plugin-v0.3.7-dev-osx-x64.tar.gz
$ mkdir -p ~/.helm/plugins/
$ tar xzvf registry-helm-plugin-v0.3.7-dev-osx-x64.tar.gz -C ~/.helm/plugins/

Linux

$ wget https://github.com/app-registry/helm-plugin/releases/download/v0.3.7/registry-helm-plugin-v0.3.7-dev-linux-x64.tar.gz
$ mkdir -p ~/.helm/plugins/
$ tar xzvf registry-helm-plugin-v0.3.7-dev-linux-x64.tar.gz -C ~/.helm/plugins/

Deploy Jenkins Using Helm from the Quay Registry

$ helm registry version quay.io

Output should be:

Api-version: {u'cnr-api': u'0.X.Y'}
Client-version: 0.X.Y

Install Jenkins

$ helm init
$ helm registry list quay.io
$ helm registry install quay.io/helm/jenkins

Create and Push Your Own Chart

First, create an account on Quay.io and login to the CLI using the username and password. Set an environment for the username created at Quay to use through the rest of these instructions.

$ export USERNAME=philips

Login to Quay with the Helm registry plugin:

$ helm registry login -u $USERNAME quay.io

Create a new Helm chart, the default will create a sample nginx application:

$ helm create nginx

Push this new chart to Quay and then deploy it from Quay.

$ cd nginx
$ helm registry push --namespace $USERNAME quay.io
$ helm registry install quay.io/$USERNAME/nginx

Working in the open with the Kubernetes community

With the exclusion of some very minor changes to Quay, all of this work is being executed in the open in collaboration with the Kubernetes community. We’ve been working with Kubernetes SIG-Apps to create an open, community-driven project called App Registry. Our goal as a community is to author libraries and a specification that align with best practices from established standards such as OCI in order to provide consistent storage and discovery for all of the tools innovating in the Kubernetes app ecosystem. While Quay currently implements a prototype of App Registry, we invite everyone to start using the feature and participate in the discussion and development as we move towards a stable release of the App Registry specification.

Learn more

If you would like to learn more and use this new feature, please go to Quay.io and start storing your applications today. If you are going to be at KubeCon next week in Berlin, please stop by our booth and talk to us and check out CoreOS CTO Brandon Philips’ keynote on day one of the conference where he’ll talk more about this.

Also you can check out the GitHub repositories for the app registry at:

https://github.com/app-registry

https://github.com/app-registry/helm-plugin