Using Docker Application Packages to Deliver Apps across Teams
Cloud native applications typically use different technologies, each with their own packaging formats. For example, If you’re working on Microsoft Azure then it would be ARM templates, or if its Kubernetes, then its Helm charts, or if it’s on AWS then it would be CloudFormation and so on.
Distributed applications usually comprise executable units and supporting API-based services. Executable units could span across environments like IaaS (like OpenStack or Azure), container orchestrators (like Kubernetes or Nomad), container runtimes (like local Docker or ACI), cloud platform services (like object storage or Database as a Service) and Functions-as-a-Service (FaaS), as well as higher-level PaaS services. Along with these components, many managed cloud services (e.g. load balancers, routers to databases) are provisioned and interconnected via REST APIs.
In the industry, currently, there is no single solution for defining and packaging multi-service, multi-format distributed applications.
In this article, we will look at how the CNAB packaging format provides application providers and developers with a way of installing a multi-component application into a distributed computing environment, supporting all of the above types, and makes it easy to deliver apps across teams, organizations and marketplaces.
Cross posted from : InfoQ.com
Introducing Cloud Native Application Bundle (CNAB)
CNAB is an open-source, cloud-agnostic specification for packaging and running distributed applications. Created by Microsoft, Docker, HashiCorp, Bitnami, Pivotal, and many others. It unifies the management of multi-service, distributed applications across different toolchains into a single all-in-one packaging format.
Simplifies complex deployments. | With CNAB, you can package multi-service, multi-format distributed applications. So deployments can be done with ease & simplified. |
Open Source, Cloud Agnostic | CNAB bundles can have varied infrastructure components or services that you need. CNABs is the right choice for your multi-cloud strategy. |
Shareable Apps | Enables Developers/Application Providers to share/deliver apps across teams, organizations, and marketplaces. |
Key benefits of CNAB
According to the CNAB Spec, CNAB packaging format brings in:
- Support for packages targeted to different runtimes and architectures.
- Internally uses containers for encapsulating installation logic so its independent of the underlying cloud environment it runs in.
- Comprises of a bundle definition file (bundle.json) to define the app, and an invocation image to install the app. The invocation image’s job is to install the required components into the host environment.
- CNAB bundle definition is a single file that contains the following information:
- Information about the bundle, like name, bundle version, description, and keywords
- Information about the invocation image (the installer program)
- List of executable images that this bundle will install
- List of credential paths or environment variables that this bundle requires to execute
- CNAB invocation image contains a standardized file system layout where metadata and installation data is stored.
- File system hierarchy as specified in the spec
- Main entry point (run tool) – Executable responsible for translating action requests (ex. Install / update etc.,) to a sequence of tasks
- Runtime metadata (For example – Helm charts, Terraform templates, etc)
- Files for constructing the images (For Example – Dockerfile)
Install Docker App
There are two ways in which you can install Docker App, either as standalone or as a CLI plugin. Pre-built static binaries are available on GitHub releases for Windows, Linux, and macOS. Here I’m going to use the Linux version and install Docker app as standalone utility.
In the below example, we are going to check how to convert an existing Compose app into a Docker App project.
Create New Helloworld Docker App
We have got the Docker App setup, use the existing Docker compose file (below) which launches an HTTP echo server that prints the specified text when hit on the configured port.
version: '3.2'
services:
hello:
image: hashicorp/http-echo
command: ["-text", "hello world"]
ports:
- 5678:5678
Run docker-app init command from the folder where compose file is located to Create a new Application Package:
docker app init --single-file hello
If you check the Docker Application Package hello.dockerapp, it will contain three YAML documents:
- First section contains metadata such as name, version, description, and maintainers.
- Second section describes the application; this is essentially your Compose file.
- Third section would have parameters for your application
If you prefer having the three core documents in separate YAML files, omit the –single-file option to the docker app init
command. This will create a new directory instead of a single file.
Edit Metadata
Let’s modify the Compose file section in helloworld.dockerapp
, by introducing variables $text and $port.
version: '3.2'
services:
hello:
image: hashicorp/http-echo
command: ["-text", "${text}"]
ports:
- ${port}:5678
Inspect Docker App
Before launching the modified Docker Application Package, let’s do inspect and check if everything looks good.
Docker App also provides validate command to check syntax and other aspects of the configuration. We are going to skip & render the app.
Render Docker App
Render command will display the compose file with the default values.
All set now, the next step is to deploy the Docker App project. Here we have 2 options, either we can launch it as a Native Docker app application or as a Compose app application.
We are going to use the Compose app option and then push the application to the DockerHub registry.
Launch Docker App
Launch Docker App with different configuration
Although Docker Compose configuration has default ports & text values, we can set the values at runtime and deploy them.
Let us try different configurations with different values for port & text.
You can also check the status of the app with the docker app status <app-name> command.
With a new Docker application package, compose configuration with default values can be pushed to DockerHub and be shared across developers/teams.
Install as Docker Native App
Application can also be installed by running docker app deploy or can use the rendered version and run docker stack deploy render/docker-compose.yml or docker-compose –f up.
Upgrade Docker App
Once your Application Packages are in DockerHub or registry, you can use commands like install, upgrade, uninstall, etc.,
Uninstall Docker App
In the next section, we will take another example that has Angular, SpringBoot & PostgreSQL stack, and create Docker Application Package out of it.
Create Docker App for Angular, SpringBoot & PostgreSQL application
Below is the compose file for the Angular, SpringBoot & PostgreSQL application that we are going to use.
version: '3'
services:
ui:
build:
context: .
dockerfile: UIDockerfile
ports:
- '4200:4200'
networks:
- samplenet
links:
- 'api:api'
api:
build:
context: .
dockerfile: AppDockerfile
ports:
- '8080:8080'
depends_on:
- db
networks:
- samplenet
links:
- 'db:db'
db:
build:
context: .
dockerfile: DBDockerfile
volumes:
- 'postgresdb:/var/lib/postgresql/data'
environment:
POSTGRES_USER: postgres
POSTGRES_PASSWORD: postgres
POSTGRES_DB: testdb
ports:
- '5432:5432'
healthcheck:
test:
- CMD-SHELL
- 'pg_isready -U postgres'
interval: 10s
timeout: 5s
retries: 5
networks:
- samplenet
networks:
samplenet: null
volumes:
postgresdb: {}
Above compose file defines 4 services:
ui
: Is for Angular application runs on port4200
.api
: Is for Spring boot application runs on port8080
.db
: Is for postgresdb application runs on port5432
.- All the above services uses
samplenet
network and - Persistent volume
postgresdb
definition is for db service - Added healthcheck section for db service to keep a tab on the health of the database
depends_on
denotes the service dependencies. When you start the services, compose would start the dependent services as well.
Run docker-app init
command from the folder where compose file is located to Create a new Application Package:
Let’s do inspect and check if everything is proper
Use render option to start the application using Docker Compose up command
Once you push it to DockerHub, you can share it with the team and they would be able to do all tasks like install, upgrade & uninstall tasks, etc.,
Application can then be installed by running docker app deploy or can use the rendered version and run docker stack deploy render/docker-compose.yml or docker-compose –f up.
Conclusion
Compose files are not easy to share between environments or across teams, Docker Application Packages solves these problems and make Compose Application reusable across multiple environments (Development/QA/Staging/Production). Docker App is currently in experimental mode and it must not be used in production environments.
Useful Resources :
- Everything You Need To Know About Docker Enterprise 3.0
- Implementing secure containers using gVisor+Docker tutorial
- ULTIMATE GUIDE to Coursera Specializations That Will Make Your Career Better (Over 100+ Specializations covered)
- Google Cloud Courses Collection
Like this post? Don’t forget to share it!
Average Rating