services:       - ${port}:5678 ``` -You can test everything is working, by inspecting the application definition.--```console-$ docker app inspect-hello 0.1.0--Maintained by: yourusername--A simple text server--Service (1) Replicas Ports Image------------ -------- ----- ------hello       1        5678  hashicorp/http-echo+Next, define the default values for the App in the `parameters.yml` file: -Parameters (2) Value--------------- ------port           5678-text           hello development+```yaml+port: 5678+text: hello development ``` -You can render the application to a Compose file with the provided default-values.--```console-$ docker app render-version: "3.2"-services:-  hello:-    command:-    - -text-    - hello development-    image: hashicorp/http-echo-    ports:-    - mode: ingress-      target: 5678-      published: 5678-      protocol: tcp-```+### Building an App image -You can then use that Compose file like any other. You could save it to disk or-pipe it straight to `docker stack` or `docker-compose` to run the-application.+Next, build an App image:  ```console-$ docker app render | docker-compose -f - up-```+$ docker app build . -f hello.dockerapp -t myrepo/hello:0.1.0+[+] Building 0.7s (6/6) FINISHED+(...) (Build output)                                                                                                                sha256:4a492748ae55170daadd1ddfff4db30e0ef3d38bf0f57a913512caa323e140de      +```                                                                               -This is where it gets interesting. We can override those parameters at runtime,-using the `--set` option. Let's specify some different options and run `render`-again:+At this point, an App image with the `myrepo/hello:1.0.1` tag has been built from the `hello.dockerapp` App definition. This immutable App image includes all the service images at fixed versions that you can run or share. -```console-$ docker app render --set port=4567 --set text="hello production"-version: "3.2"-services:-  hello:-    command:-    - -text-    - hello production-    image: hashicorp/http-echo-    ports:-    - mode: ingress-      target: 5678-      published: 4567-      protocol: tcp-```+### Sharing and running the App -If you prefer you can create a standalone configuration file to store those-parameters. Let's create `prod.yml` with the following contents:--```yaml-text: hello production-port: 4567-```--You can then run using that configuration file like so:+To share your App image, push it to a container registry.  ```console-$ docker app render --parameters-file prod.yml-```+$ docker app push myrepo/hello:0.1.0+```   -You can share your Application Package by pushing it to a container registry.+Now run your App:  ```console-$ docker app push --tag myrepo/hello:0.1.0-```+$ docker app run myrepo/hello:0.1.0 +```  -Others can then use your Application Package by specifying the registry tag.+You can specify the Docker endpoint where an application is installed using a context. By default, your App will run on the currently active context. You can select another context with the `docker context use` command, and the `docker app run` command will thereafter run your app on this particular context.  -```console-$ docker app inspect myrepo/hello:0.1.0-```+Whenever you define such a context, the installer image will run in the default context (i.e., on local host). You can then use the `--installer-context` to target another context to run the installer image. -**Note**: Commands like `install`, `upgrade`, `render`, etc. can also be used-directly on Application Packages that are in a registry.--You can specify the Docker endpoint where an application is installed using a-context and the `--context` option. If you do not specify one, it will	-use the currently active context.+```console+$ docker context create remote --description "remote cluster" --docker host=tcp://<remote-ip>:<remote-port>+Successfully created context "remote" -Whenever you define such a context, the installer image will run in the `default`-context (i.e. on local host). You can use the `--installer-context` to target-another context to run the installer image.+$ docker context ls+NAME                DESCRIPTION                               DOCKER ENDPOINT               KUBERNETES ENDPOINT                ORCHESTRATOR+default *           Current DOCKER_HOST based configuration   unix:///var/run/docker.sock   https://localhost:6443 (default)   swarm+remote              remote cluster                            tcp://<remote-ip>:<remote-port> -More examples are available in the [examples](examples) directory.+$ docker context use remote+$ docker app run myrepo/hello:0.1.0+```   ## CNAB -Under the hood `docker app` is [CNAB](https://cnab.io) compliant. It generates a-CNAB from your application source and is able to install and manage any other-CNAB too. CNAB specifies three actions which `docker app` provides as commands:-* `install`-* `upgrade`-* `uninstall`--Here is an example installing an Application Package, inspect it and-then uninstalling it:-```console-$ docker app install examples/hello-world/example-hello-world.dockerapp --name hello-Creating network hello_default-Creating service hello_hello--$ docker app inspect hello-{-    "Metadata": {-        "version": "0.1.0",-        "name": "hello-world",-        "description": "Hello, World!",-        "maintainers": [-            {-                "name": "user",-                "email": "[email protected]"-            }-        ]-    },-    "Services": [-        {-            "Name": "hello",-            "Image": "hashicorp/http-echo",-            "Replicas": 1,-            "Ports": "8080"-        }-    ],-    "Parameters": {-        "port": "8080",-        "text": "Hello, World!"-    },-    "Attachments": [-        {-            "Path": "bundle.json",-            "Size": 3189-        }-    ]-}--$ docker app uninstall hello-Removing service hello_hello-Removing network hello_default-```+Docker Apps are Docker’s implementation of the industry standard Cloud Native Application Bundle (CNAB). [CNAB](https://cnab.io/) is an industry specification put in place to facilitate the bundling, sharing, installing and managing of cloud-native apps that are not only made up of containers but also from such things as hosted databases, functions, etc. +Docker App is designed to abstract as many CNAB specifics as possible, to provide users with a tool that is easy to use while alleviating the need to bother with the CNAB specification.  ## Installation -**Note**: Docker app is a _command line_ plugin (not be confused with docker _engine_ plugins), extending the `docker` command with `app` sub-commands.-It requires [Docker CLI](https://download.docker.com) 19.03.0 or later with experimental features enabled.-Either set environment variable `DOCKER_CLI_EXPERIMENTAL=enabled`-or update your [docker CLI configuration](https://docs.docker.com/engine/reference/commandline/cli/#experimental-features).--**Note**: Docker-app can't be installed using the `docker plugin install` command (yet)+Docker App is a *command line* plugin (not be confused with *docker engine plugins*) that extends the `docker` command with `app` sub-commands. It requires [Docker CLI](https://download.docker.com/) 19.03.0 or later, with experimental features enabled. Either set environment variable `DOCKER_CLI_EXPERIMENTAL=enabled` or update your [docker CLI configuration](https://docs.docker.com/engine/reference/commandline/cli/#experimental-features).

 services:       - 5678:5678 ``` -With `docker app` [installed](#installation) let's create an Application Package-based on this Compose file:+Next, create an App definition using the `docker app init` command:  ```console-$ docker app init hello+$ docker app init --compose-file docker-compose.yml hello+Created "hello.dockerapp" $ ls

-# Docker Application+# Docker App -A Docker CLI Plugin to configure, share and install applications:-* Extend [Compose files](https://docs.docker.com/compose/compose-file/) with metadata and parameters-* Re-use same application across multiple environments (Development/QA/Staging/Production)-* Multi orchestrator installation (Swarm or Kubernetes)-* Push/Pull/[Promotion](https://docs.docker.com/ee/dtr/user/promotion-policies/internal-promotion/)/[Signing](https://docs.docker.com/engine/security/trust/content_trust/) supported for application, with same workflow as images-* Fully [CNAB](https://cnab.io) compliant-* Full support of Docker Contexts+Docker App is a Cloud Native application packaging framework with which developers and devops can  build, share, and run a set of microservices as a single entity. Docker Apps are based on the [Compose format](https://docs.docker.com/compose/compose-file/), which permits [docker-compose](https://github.com/docker/compose) users to easily share their Compose-based multiservice applications via container registries. By leveraging containers, Docker App makes it possible to easily change parts of the application and to share the application through container registries. -## The problem Application Packages solves+### Table of Contents+- **[What are the benefits offered by Docker App?](#what-are-the-benefits-offered-by-docker-app)**+- **[How does Docker App work?](#how-does-docker-app-work)**+- **[Using Docker App](#using-docker-app)**+    * **[Writing an App definition](#writing-an-app-definition)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing the App on the Hub](#sharing-apps-on-the-hub)**+    * **[Running the App](#running-the-app)**+- **[Example](#example)**+    * **[App definition](#app-definition)**+    * **[Using parameters](#using-parameters)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing and running the App](#sharing-and-running-the-app)**+- **[CNAB](#cnab)**+- **[Installation](#installation)**+    * **[Linux or macOS](#linux-or-macos)**+    * **[Windows](#windows)**+- **[Next steps](#next-steps)** -Compose files do a great job of describing a set of related services. Not only-are Compose files easy to write, they are generally easy to read as well.-However, a couple of problems often emerge:+## What are the benefits offered by Docker App? -1. You have several environments where you want to deploy the application, with small configuration differences-1. You have lots of similar applications+* Simple management of Docker Apps across different teams and between different environments (Development/QA/Staging/Production)+* Easy sharing of multi-service applications to container registries (e.g., [Docker Hub](https://hub.docker.com/) or [Docker Trusted Registry](https://docs.docker.com/ee/dtr/))+* Having a clear separation of parameters to be modified at runtime +* Support for multiple orchestrators (Swarm or Kubernetes)+* Provides the very same UX flow as the one for Docker images+* Implements the [CNAB](https://cnab.io) industry standard+* Offers full support of Docker Contexts -Fundamentally, Compose files are not easy to share between concerns. Docker-Application Packages aim to solve these problems and make Compose more useful-for development _and_ production.+## How does Docker App work? -## Looking at an example+The Docker App workflow is quite similar to the Docker image workflow. From an App definition, you can build an App image, share it on Docker Hub, and run your App on an orchestrator. -Let's take the following Compose file. It launches an HTTP server which prints-the specified text when hit on the configured port.+![Image showing Docker CLI command flow](./DockerAppCLIcommands.png)++## Using Docker App++Four primary steps comprise the Docker App process:+1. Writing an App Definition+1. Building an App Image+1. Sharing the App on the Hub (optional)+1. Running the App++### Writing an App definition++The first step in using Docker App is to write the App definition. This definition can be created (1) from an existing Compose file using the `docker app init` command (2) via  a template from the Application Designer, or (3) from scratch. ++The App definition is a .dockerapp folder that contains three distinct pieces: metadata, a service list, and the parameters. ++metadata | Includes the App name and version; provides better traceability back to code changes when debugging issues+service list | Defined in a Compose file+parameters | Settings that can be changed when running the App++*Note: To store additional files in Docker Apps, such as* `prod.yml`*,* `test.yml` *or other config files, you need only to add these files to the *.dockerapp directory. All files will be packaged into the App image through the use of the* `docker app build`  *command.*++### Building an App image++Once the App definition is written, the next step is to build the App image from the App definition using the `docker app build` command. With this command you can tag your App image, set build-time variables, or make the build quiet. +Note that service images inside of an App image are immutable, meaning that the App version ties to a fixed list of service images (i.e., updating the images inside of a Docker App requires recreating the App image).++### Sharing the App on the Hub++You can push any App image already built or pulled to Docker Hub (or any registry) using the `docker app push` command. You can also pull App images from any container registry using the `docker app pull` command.

-# Docker Application+# Docker App -A Docker CLI Plugin to configure, share and install applications:-* Extend [Compose files](https://docs.docker.com/compose/compose-file/) with metadata and parameters-* Re-use same application across multiple environments (Development/QA/Staging/Production)-* Multi orchestrator installation (Swarm or Kubernetes)-* Push/Pull/[Promotion](https://docs.docker.com/ee/dtr/user/promotion-policies/internal-promotion/)/[Signing](https://docs.docker.com/engine/security/trust/content_trust/) supported for application, with same workflow as images-* Fully [CNAB](https://cnab.io) compliant-* Full support of Docker Contexts+Docker App is a Cloud Native application packaging framework with which developers and devops can  build, share, and run a set of microservices as a single entity. Docker Apps are based on the [Compose format](https://docs.docker.com/compose/compose-file/), which permits [docker-compose](https://github.com/docker/compose) users to easily share their Compose-based multiservice applications via container registries. By leveraging containers, Docker App makes it possible to easily change parts of the application and to share the application through container registries. -## The problem Application Packages solves+### Table of Contents+- **[What are the benefits offered by Docker App?](#what-are-the-benefits-offered-by-docker-app)**+- **[How does Docker App work?](#how-does-docker-app-work)**+- **[Using Docker App](#using-docker-app)**+    * **[Writing an App definition](#writing-an-app-definition)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing the App on the Hub](#sharing-apps-on-the-hub)**+    * **[Running the App](#running-the-app)**+- **[Example](#example)**+    * **[App definition](#app-definition)**+    * **[Using parameters](#using-parameters)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing and running the App](#sharing-and-running-the-app)**+- **[CNAB](#cnab)**+- **[Installation](#installation)**+    * **[Linux or macOS](#linux-or-macos)**+    * **[Windows](#windows)**+- **[Next steps](#next-steps)** -Compose files do a great job of describing a set of related services. Not only-are Compose files easy to write, they are generally easy to read as well.-However, a couple of problems often emerge:+## What are the benefits offered by Docker App? -1. You have several environments where you want to deploy the application, with small configuration differences-1. You have lots of similar applications+* Simple management of Docker Apps across different teams and between different environments (Development/QA/Staging/Production)+* Easy sharing of multi-service applications to container registries (e.g., [Docker Hub](https://hub.docker.com/) or [Docker Trusted Registry](https://docs.docker.com/ee/dtr/))+* Having a clear separation of parameters to be modified at runtime +* Support for multiple orchestrators (Swarm or Kubernetes)+* Provides the very same UX flow as the one for Docker images+* Implements the [CNAB](https://cnab.io) industry standard+* Offers full support of Docker Contexts -Fundamentally, Compose files are not easy to share between concerns. Docker-Application Packages aim to solve these problems and make Compose more useful-for development _and_ production.+## How does Docker App work? -## Looking at an example+The Docker App workflow is quite similar to the Docker image workflow. From an App definition, you can build an App image, share it on Docker Hub, and run your App on an orchestrator. -Let's take the following Compose file. It launches an HTTP server which prints-the specified text when hit on the configured port.+![Image showing Docker CLI command flow](./DockerAppCLIcommands.png)++## Using Docker App++Four primary steps comprise the Docker App process:+1. Writing an App Definition+1. Building an App Image+1. Sharing the App on the Hub (optional)+1. Running the App++### Writing an App definition++The first step in using Docker App is to write the App definition. This definition can be created (1) from an existing Compose file using the `docker app init` command (2) via  a template from the Application Designer, or (3) from scratch. ++The App definition is a .dockerapp folder that contains three distinct pieces: metadata, a service list, and the parameters. ++metadata | Includes the App name and version; provides better traceability back to code changes when debugging issues+service list | Defined in a Compose file+parameters | Settings that can be changed when running the App++*Note: To store additional files in Docker Apps, such as* `prod.yml`*,* `test.yml` *or other config files, you need only to add these files to the *.dockerapp directory. All files will be packaged into the App image through the use of the* `docker app build`  *command.*++### Building an App image++Once the App definition is written, the next step is to build the App image from the App definition using the `docker app build` command. With this command you can tag your App image, set build-time variables, or make the build quiet. +Note that service images inside of an App image are immutable, meaning that the App version ties to a fixed list of service images (i.e., updating the images inside of a Docker App requires recreating the App image).

-# Docker Application+# Docker App -A Docker CLI Plugin to configure, share and install applications:-* Extend [Compose files](https://docs.docker.com/compose/compose-file/) with metadata and parameters-* Re-use same application across multiple environments (Development/QA/Staging/Production)-* Multi orchestrator installation (Swarm or Kubernetes)-* Push/Pull/[Promotion](https://docs.docker.com/ee/dtr/user/promotion-policies/internal-promotion/)/[Signing](https://docs.docker.com/engine/security/trust/content_trust/) supported for application, with same workflow as images-* Fully [CNAB](https://cnab.io) compliant-* Full support of Docker Contexts+Docker App is a Cloud Native application packaging framework with which developers and devops can  build, share, and run a set of microservices as a single entity. Docker Apps are based on the [Compose format](https://docs.docker.com/compose/compose-file/), which permits [docker-compose](https://github.com/docker/compose) users to easily share their Compose-based multiservice applications via container registries. By leveraging containers, Docker App makes it possible to easily change parts of the application and to share the application through container registries. -## The problem Application Packages solves+### Table of Contents+- **[What are the benefits offered by Docker App?](#what-are-the-benefits-offered-by-docker-app)**+- **[How does Docker App work?](#how-does-docker-app-work)**+- **[Using Docker App](#using-docker-app)**+    * **[Writing an App definition](#writing-an-app-definition)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing the App on the Hub](#sharing-apps-on-the-hub)**+    * **[Running the App](#running-the-app)**+- **[Example](#example)**+    * **[App definition](#app-definition)**+    * **[Using parameters](#using-parameters)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing and running the App](#sharing-and-running-the-app)**+- **[CNAB](#cnab)**+- **[Installation](#installation)**+    * **[Linux or macOS](#linux-or-macos)**+    * **[Windows](#windows)**+- **[Next steps](#next-steps)** -Compose files do a great job of describing a set of related services. Not only-are Compose files easy to write, they are generally easy to read as well.-However, a couple of problems often emerge:+## What are the benefits offered by Docker App? -1. You have several environments where you want to deploy the application, with small configuration differences-1. You have lots of similar applications+* Simple management of Docker Apps across different teams and between different environments (Development/QA/Staging/Production)+* Easy sharing of multi-service applications to container registries (e.g., [Docker Hub](https://hub.docker.com/) or [Docker Trusted Registry](https://docs.docker.com/ee/dtr/))+* Having a clear separation of parameters to be modified at runtime +* Support for multiple orchestrators (Swarm or Kubernetes)+* Provides the very same UX flow as the one for Docker images+* Implements the [CNAB](https://cnab.io) industry standard+* Offers full support of Docker Contexts -Fundamentally, Compose files are not easy to share between concerns. Docker-Application Packages aim to solve these problems and make Compose more useful-for development _and_ production.+## How does Docker App work? -## Looking at an example+The Docker App workflow is quite similar to the Docker image workflow. From an App definition, you can build an App image, share it on Docker Hub, and run your App on an orchestrator. -Let's take the following Compose file. It launches an HTTP server which prints-the specified text when hit on the configured port.+![Image showing Docker CLI command flow](./DockerAppCLIcommands.png)++## Using Docker App++Four primary steps comprise the Docker App process:+1. Writing an App Definition+1. Building an App Image+1. Sharing the App on the Hub (optional)+1. Running the App++### Writing an App definition++The first step in using Docker App is to write the App definition. This definition can be created (1) from an existing Compose file using the `docker app init` command (2) via  a template from the Application Designer, or (3) from scratch. ++The App definition is a .dockerapp folder that contains three distinct pieces: metadata, a service list, and the parameters. ++metadata | Includes the App name and version; provides better traceability back to code changes when debugging issues+service list | Defined in a Compose file

-# Docker Application+# Docker App -A Docker CLI Plugin to configure, share and install applications:-* Extend [Compose files](https://docs.docker.com/compose/compose-file/) with metadata and parameters-* Re-use same application across multiple environments (Development/QA/Staging/Production)-* Multi orchestrator installation (Swarm or Kubernetes)-* Push/Pull/[Promotion](https://docs.docker.com/ee/dtr/user/promotion-policies/internal-promotion/)/[Signing](https://docs.docker.com/engine/security/trust/content_trust/) supported for application, with same workflow as images-* Fully [CNAB](https://cnab.io) compliant-* Full support of Docker Contexts+Docker App is a Cloud Native application packaging framework with which developers and devops can  build, share, and run a set of microservices as a single entity. Docker Apps are based on the [Compose format](https://docs.docker.com/compose/compose-file/), which permits [docker-compose](https://github.com/docker/compose) users to easily share their Compose-based multiservice applications via container registries. By leveraging containers, Docker App makes it possible to easily change parts of the application and to share the application through container registries. -## The problem Application Packages solves+### Table of Contents+- **[What are the benefits offered by Docker App?](#what-are-the-benefits-offered-by-docker-app)**+- **[How does Docker App work?](#how-does-docker-app-work)**+- **[Using Docker App](#using-docker-app)**+    * **[Writing an App definition](#writing-an-app-definition)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing the App on the Hub](#sharing-apps-on-the-hub)**+    * **[Running the App](#running-the-app)**+- **[Example](#example)**+    * **[App definition](#app-definition)**+    * **[Using parameters](#using-parameters)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing and running the App](#sharing-and-running-the-app)**+- **[CNAB](#cnab)**+- **[Installation](#installation)**+    * **[Linux or macOS](#linux-or-macos)**+    * **[Windows](#windows)**+- **[Next steps](#next-steps)** -Compose files do a great job of describing a set of related services. Not only-are Compose files easy to write, they are generally easy to read as well.-However, a couple of problems often emerge:+## What are the benefits offered by Docker App? -1. You have several environments where you want to deploy the application, with small configuration differences-1. You have lots of similar applications+* Simple management of Docker Apps across different teams and between different environments (Development/QA/Staging/Production)+* Easy sharing of multi-service applications to container registries (e.g., [Docker Hub](https://hub.docker.com/) or [Docker Trusted Registry](https://docs.docker.com/ee/dtr/))+* Having a clear separation of parameters to be modified at runtime +* Support for multiple orchestrators (Swarm or Kubernetes)+* Provides the very same UX flow as the one for Docker images+* Implements the [CNAB](https://cnab.io) industry standard+* Offers full support of Docker Contexts -Fundamentally, Compose files are not easy to share between concerns. Docker-Application Packages aim to solve these problems and make Compose more useful-for development _and_ production.+## How does Docker App work? -## Looking at an example+The Docker App workflow is quite similar to the Docker image workflow. From an App definition, you can build an App image, share it on Docker Hub, and run your App on an orchestrator. -Let's take the following Compose file. It launches an HTTP server which prints-the specified text when hit on the configured port.+![Image showing Docker CLI command flow](./DockerAppCLIcommands.png)++## Using Docker App++Four primary steps comprise the Docker App process:+1. Writing an App Definition+1. Building an App Image+1. Sharing the App on the Hub (optional)+1. Running the App++### Writing an App definition++The first step in using Docker App is to write the App definition. This definition can be created (1) from an existing Compose file using the `docker app init` command (2) via  a template from the Application Designer, or (3) from scratch. ++The App definition is a .dockerapp folder that contains three distinct pieces: metadata, a service list, and the parameters. ++metadata | Includes the App name and version; provides better traceability back to code changes when debugging issues+service list | Defined in a Compose file+parameters | Settings that can be changed when running the App

-# Docker Application+# Docker App -A Docker CLI Plugin to configure, share and install applications:-* Extend [Compose files](https://docs.docker.com/compose/compose-file/) with metadata and parameters-* Re-use same application across multiple environments (Development/QA/Staging/Production)-* Multi orchestrator installation (Swarm or Kubernetes)-* Push/Pull/[Promotion](https://docs.docker.com/ee/dtr/user/promotion-policies/internal-promotion/)/[Signing](https://docs.docker.com/engine/security/trust/content_trust/) supported for application, with same workflow as images-* Fully [CNAB](https://cnab.io) compliant-* Full support of Docker Contexts+Docker App is a Cloud Native application packaging framework with which developers and devops can  build, share, and run a set of microservices as a single entity. Docker Apps are based on the [Compose format](https://docs.docker.com/compose/compose-file/), which permits [docker-compose](https://github.com/docker/compose) users to easily share their Compose-based multiservice applications via container registries. By leveraging containers, Docker App makes it possible to easily change parts of the application and to share the application through container registries. -## The problem Application Packages solves+### Table of Contents+- **[What are the benefits offered by Docker App?](#what-are-the-benefits-offered-by-docker-app)**+- **[How does Docker App work?](#how-does-docker-app-work)**+- **[Using Docker App](#using-docker-app)**+    * **[Writing an App definition](#writing-an-app-definition)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing the App on the Hub](#sharing-apps-on-the-hub)**+    * **[Running the App](#running-the-app)**+- **[Example](#example)**+    * **[App definition](#app-definition)**+    * **[Using parameters](#using-parameters)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing and running the App](#sharing-and-running-the-app)**+- **[CNAB](#cnab)**+- **[Installation](#installation)**+    * **[Linux or macOS](#linux-or-macos)**+    * **[Windows](#windows)**+- **[Next steps](#next-steps)** -Compose files do a great job of describing a set of related services. Not only-are Compose files easy to write, they are generally easy to read as well.-However, a couple of problems often emerge:+## What are the benefits offered by Docker App? -1. You have several environments where you want to deploy the application, with small configuration differences-1. You have lots of similar applications+* Simple management of Docker Apps across different teams and between different environments (Development/QA/Staging/Production)+* Easy sharing of multi-service applications to container registries (e.g., [Docker Hub](https://hub.docker.com/) or [Docker Trusted Registry](https://docs.docker.com/ee/dtr/))+* Having a clear separation of parameters to be modified at runtime +* Support for multiple orchestrators (Swarm or Kubernetes)+* Provides the very same UX flow as the one for Docker images+* Implements the [CNAB](https://cnab.io) industry standard+* Offers full support of Docker Contexts -Fundamentally, Compose files are not easy to share between concerns. Docker-Application Packages aim to solve these problems and make Compose more useful-for development _and_ production.+## How does Docker App work? -## Looking at an example+The Docker App workflow is quite similar to the Docker image workflow. From an App definition, you can build an App image, share it on Docker Hub, and run your App on an orchestrator. -Let's take the following Compose file. It launches an HTTP server which prints-the specified text when hit on the configured port.+![Image showing Docker CLI command flow](./DockerAppCLIcommands.png)++## Using Docker App++Four primary steps comprise the Docker App process:+1. Writing an App Definition+1. Building an App Image+1. Sharing the App on the Hub (optional)+1. Running the App++### Writing an App definition++The first step in using Docker App is to write the App definition. This definition can be created (1) from an existing Compose file using the `docker app init` command (2) via  a template from the Application Designer, or (3) from scratch. ++The App definition is a .dockerapp folder that contains three distinct pieces: metadata, a service list, and the parameters. ++metadata | Includes the App name and version; provides better traceability back to code changes when debugging issues

-# Docker Application+# Docker App -A Docker CLI Plugin to configure, share and install applications:-* Extend [Compose files](https://docs.docker.com/compose/compose-file/) with metadata and parameters-* Re-use same application across multiple environments (Development/QA/Staging/Production)-* Multi orchestrator installation (Swarm or Kubernetes)-* Push/Pull/[Promotion](https://docs.docker.com/ee/dtr/user/promotion-policies/internal-promotion/)/[Signing](https://docs.docker.com/engine/security/trust/content_trust/) supported for application, with same workflow as images-* Fully [CNAB](https://cnab.io) compliant-* Full support of Docker Contexts+Docker App is a Cloud Native application packaging framework with which developers and devops can  build, share, and run a set of microservices as a single entity. Docker Apps are based on the [Compose format](https://docs.docker.com/compose/compose-file/), which permits [docker-compose](https://github.com/docker/compose) users to easily share their Compose-based multiservice applications via container registries. By leveraging containers, Docker App makes it possible to easily change parts of the application and to share the application through container registries. -## The problem Application Packages solves+### Table of Contents+- **[What are the benefits offered by Docker App?](#what-are-the-benefits-offered-by-docker-app)**+- **[How does Docker App work?](#how-does-docker-app-work)**+- **[Using Docker App](#using-docker-app)**+    * **[Writing an App definition](#writing-an-app-definition)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing the App on the Hub](#sharing-apps-on-the-hub)**+    * **[Running the App](#running-the-app)**+- **[Example](#example)**+    * **[App definition](#app-definition)**+    * **[Using parameters](#using-parameters)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing and running the App](#sharing-and-running-the-app)**+- **[CNAB](#cnab)**+- **[Installation](#installation)**+    * **[Linux or macOS](#linux-or-macos)**+    * **[Windows](#windows)**+- **[Next steps](#next-steps)** -Compose files do a great job of describing a set of related services. Not only-are Compose files easy to write, they are generally easy to read as well.-However, a couple of problems often emerge:+## What are the benefits offered by Docker App? -1. You have several environments where you want to deploy the application, with small configuration differences-1. You have lots of similar applications+* Simple management of Docker Apps across different teams and between different environments (Development/QA/Staging/Production)+* Easy sharing of multi-service applications to container registries (e.g., [Docker Hub](https://hub.docker.com/) or [Docker Trusted Registry](https://docs.docker.com/ee/dtr/))+* Having a clear separation of parameters to be modified at runtime +* Support for multiple orchestrators (Swarm or Kubernetes)+* Provides the very same UX flow as the one for Docker images+* Implements the [CNAB](https://cnab.io) industry standard+* Offers full support of Docker Contexts -Fundamentally, Compose files are not easy to share between concerns. Docker-Application Packages aim to solve these problems and make Compose more useful-for development _and_ production.+## How does Docker App work? -## Looking at an example+The Docker App workflow is quite similar to the Docker image workflow. From an App definition, you can build an App image, share it on Docker Hub, and run your App on an orchestrator. -Let's take the following Compose file. It launches an HTTP server which prints-the specified text when hit on the configured port.+![Image showing Docker CLI command flow](./DockerAppCLIcommands.png)++## Using Docker App++Four primary steps comprise the Docker App process:+1. Writing an App Definition+1. Building an App Image+1. Sharing the App on the Hub (optional)+1. Running the App++### Writing an App definition++The first step in using Docker App is to write the App definition. This definition can be created (1) from an existing Compose file using the `docker app init` command (2) via  a template from the Application Designer, or (3) from scratch. 

 func getImageListColumns(options imageListOption) []imageListColumn { 		imageListColumn{"APP NAME", func(p pkg) string { 			return p.bundle.Name 		}},+		imageListColumn{"CREATED", func(p pkg) string {+			payload, err := packager.CustomPayload(p.bundle.Bundle)+			if err != nil {+				return ""+			}+			if createdPayload, ok := payload.(packager.CustomPayloadCreated); ok {+				return units.HumanDuration(time.Now().UTC().Sub(createdPayload.CreatedTime())) + " ago"+			}+			return ""

 func verifyImageIDListOutput(t *testing.T, cmd icmd.Cmd, count int, distinct int 	for scanner.Scan() { 		lines = append(lines, scanner.Text()) 		counter[scanner.Text()]+++		fmt.Println(scanner.Text())

 func insertBundles(t *testing.T, cmd icmd.Cmd) {  func assertImageListOutput(t *testing.T, cmd icmd.Cmd, expected string) { 	result := icmd.RunCmd(cmd).Assert(t, icmd.Success)-	match, _ := regexp.MatchString(expected, result.Stdout())+	stdout := result.Stdout()+	match, _ := regexp.MatchString(expected, stdout)+	if !match {+		fmt.Println(stdout)+	} 	assert.Assert(t, match)

 func insertBundles(t *testing.T, cmd icmd.Cmd) {  func assertImageListOutput(t *testing.T, cmd icmd.Cmd, expected string) { 	result := icmd.RunCmd(cmd).Assert(t, icmd.Success)-	match, _ := regexp.MatchString(expected, result.Stdout())+	stdout := result.Stdout()+	match, _ := regexp.MatchString(expected, stdout)

-# Docker Application+# Docker App -A Docker CLI Plugin to configure, share and install applications:-* Extend [Compose files](https://docs.docker.com/compose/compose-file/) with metadata and parameters-* Re-use same application across multiple environments (Development/QA/Staging/Production)-* Multi orchestrator installation (Swarm or Kubernetes)-* Push/Pull/[Promotion](https://docs.docker.com/ee/dtr/user/promotion-policies/internal-promotion/)/[Signing](https://docs.docker.com/engine/security/trust/content_trust/) supported for application, with same workflow as images-* Fully [CNAB](https://cnab.io) compliant-* Full support of Docker Contexts+Docker App is a Cloud Native application packaging framework with which developers and devops can  build, share, and run a set of microservices as a single entity. Docker Apps are based on the [Compose format](https://docs.docker.com/compose/compose-file/), which permits [docker-compose](https://github.com/docker/compose) users to easily share their Compose-based multiservice applications via container registries. By leveraging containers, Docker App makes it possible to easily change parts of the application and to share the application through container registries. -## The problem Application Packages solves+### Table of Contents+- **[What are the benefits offered by Docker App?](#what-are-the-benefits-offered-by-docker-app)**+- **[How does Docker App work?](#how-does-docker-app-work)**+- **[Using Docker App](#using-docker-app)**+    * **[Writing an App definition](#writing-an-app-definition)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing the App on the Hub](#sharing-apps-on-the-hub)**+    * **[Running the App](#running-the-app)**+- **[Example](#example)**+    * **[App definition](#app-definition)**+    * **[Using parameters](#using-parameters)**+    * **[Building an App image](#building-an-app-image)**+    * **[Sharing and running the App](#sharing-and-running-the-app)**+- **[CNAB](#cnab)**+- **[Installation](#installation)**+    * **[Linux or macOS](#linux-or-macos)**+    * **[Windows](#windows)**+- **[Next steps](#next-steps)** -Compose files do a great job of describing a set of related services. Not only-are Compose files easy to write, they are generally easy to read as well.-However, a couple of problems often emerge:+## What are the benefits offered by Docker App? -1. You have several environments where you want to deploy the application, with small configuration differences-1. You have lots of similar applications+* Simple management of Docker Apps across different teams and between different environments (Development/QA/Staging/Production)+* Easy sharing of multi-service applications to container registries (e.g., [Docker Hub](https://hub.docker.com/) or [Docker Trusted Registry](https://docs.docker.com/ee/dtr/)) via multiple Docker images

+package packager++import (+	"encoding/json"+	"time"++	"github.com/deislabs/cnab-go/bundle"+	"github.com/docker/app/internal"+)++const (+	// DockerAppCustomVersion1_0_0 is the custom payload version 1.0.0+	DockerAppCustomVersion1_0_0 = "1.0.0"++	// DockerAppCustomVersionCurrent the current payload version+	DockerAppCustomVersionCurrent = DockerAppCustomVersion1_0_0+)++// DockerAppCustom contains extension custom data that docker app injects+// in the bundle.+type DockerAppCustom struct {+	Version string          `json:"version,omitempty"`+	Payload json.RawMessage `json:"payload,omitempty"`+}++// CustomPayloadCreated is a custom payload with a created time+type CustomPayloadCreated interface {

 required = ["github.com/wadey/gocovmerge"]   name = "github.com/opencontainers/runtime-spec"   revision = "29686dbc5559d93fb1ef402eeda3e35c38d75af4" +[[override]]+  name = "github.com/Microsoft/hcsshim"+  revision = "2226e083fc390003ae5aa8325c3c92789afa0e7a"+

 func (cli *DockerCli) ServerInfo() ServerInfo {  // ClientInfo returns the client details for the cli func (cli *DockerCli) ClientInfo() ClientInfo {-	return cli.clientInfo+

 func TestListCmd(t *testing.T) { 	}{ 		{ 			name: "TestList",-			expectedOutput: `REPOSITORY                                                       TAG    APP IMAGE ID APP NAME-foo/bar                                                          <none> 3f825b2d0657 Digested App-foo/bar                                                          1.0    9aae408ee04f Foo App-a855ac937f2ed375ba4396bbc49c4093e124da933acd2713fb9bc17d7562a087 <none> a855ac937f2e Quiet App+			expectedOutput: `REPOSITORY TAG    APP IMAGE ID APP NAME+foo/bara   <none> 3f825b2d0657 Digested App

 func TestRenderFormatters(t *testing.T) { 	}) } +func checkFileWarning(t *testing.T, goldenFile, composeData string) {+	cmd, cleanup := dockerCli.createTestCmd()+	defer cleanup()++	tmpDir := fs.NewDir(t, "app_input",+		fs.WithFile(internal.ComposeFileName, composeData),+	)+	defer tmpDir.Remove()++	cmd.Dir = tmpDir.Path()+	cmd.Command = dockerCli.Command("app", "init", "app-test",+		"--compose-file", tmpDir.Join(internal.ComposeFileName))+	stdErr := icmd.RunCmd(cmd).Assert(t, icmd.Success).Stderr()+	golden.Assert(t, stdErr, goldenFile)+}++func TestInitWarningEnvFiles(t *testing.T) {+	testCases := []struct {+		name    string+		golden  string+		compose string+	}{+		{+			name:   "initWarningMultipleEnvFilesTest",

+package relocated++import (+	"io/ioutil"+	"os"++	"github.com/deislabs/cnab-go/bundle"+	"github.com/docker/cnab-to-oci/relocation"+	"github.com/docker/go/canonical/json"+)++type Bundle struct {+	*bundle.Bundle+	RelocationMap relocation.ImageRelocationMap+}++// FromBundle returns a RelocatedBundle with an empty relocation map.+func FromBundle(bndl *bundle.Bundle) *Bundle {+	return &Bundle{+		Bundle:        bndl,+		RelocationMap: relocation.ImageRelocationMap{},+	}+}++// WriteRelocationMap serializes the relocation map and writes it to a file as JSON.+func (b *Bundle) WriteRelocationMap(dest string, mode os.FileMode) error {

 func (b *bundleStore) Store(ref reference.Reference, bndle *bundle.Bundle) (refe 	if err != nil { 		return id, errors.Wrapf(err, "failed to store bundle %q", ref) 	}-	path := filepath.Join(dir, "bundle.json") 	if err := os.MkdirAll(dir, 0755); err != nil { 		return id, errors.Wrapf(err, "failed to store bundle %q", ref) 	}-	if err = bndle.WriteFile(path, 0644); err != nil {++	// store bundle.json+	path := filepath.Join(dir, "bundle.json")+	if err = bndl.WriteFile(path, 0644); err != nil { 		return id, errors.Wrapf(err, "failed to store bundle %q", ref) 	}++	// store relocation map+	relocationMapPath := filepath.Join(dir, "relocation-map.json")+	if err = bndl.WriteRelocationMap(relocationMapPath, 0644); err != nil {

+package relocated++import (+	"io/ioutil"+	"os"++	"github.com/deislabs/cnab-go/bundle"+	"github.com/docker/cnab-to-oci/relocation"+	"github.com/docker/go/canonical/json"+)++type Bundle struct {+	*bundle.Bundle+	RelocationMap relocation.ImageRelocationMap+}++// FromBundle returns a RelocatedBundle with an empty relocation map.+func FromBundle(bndl *bundle.Bundle) *Bundle {+	return &Bundle{+		Bundle:        bndl,+		RelocationMap: relocation.ImageRelocationMap{},+	}+}++// WriteRelocationMap serializes the relocation map and writes it to a file as JSON.+func (b *Bundle) WriteRelocationMap(dest string, mode os.FileMode) error {

+package relocated

+package fetch++import (+	"io/ioutil"+	"os"+	"path/filepath"++	"github.com/deislabs/cnab-go/bundle"+	"github.com/docker/app/internal/relocated"+	"github.com/docker/cnab-to-oci/relocation"+	"github.com/docker/go/canonical/json"+	"github.com/pkg/errors"+)++func BundleJSON(bundlePath string) (*bundle.Bundle, error) {+	data, err := ioutil.ReadFile(bundlePath)+	if err != nil {+		return nil, errors.Wrapf(err, "failed to read file %s", bundlePath)+	}+	bndl, err := bundle.Unmarshal(data)+	if err != nil {+		return nil, errors.Wrapf(err, "failed to read file %s", bundlePath)+	}+	return bndl, nil+}++func RelocationMapJSON(relocationMapPath string) (relocation.ImageRelocationMap, error) {

 import ( 	"github.com/spf13/cobra" ) +type parametersOptions struct {+	ParametersFiles []string+	Overrides       []string+}++func (o *parametersOptions) addFlags(flags *pflag.FlagSet) {

 import ( 	"github.com/spf13/cobra" ) +type parametersOptions struct {+	ParametersFiles []string+	Overrides       []string+}++func (o *parametersOptions) addFlags(flags *pflag.FlagSet) {

-package commands

 func PrepareDriver(dockerCli command.Cli, bindMount BindMount, stdout io.Writer) 	for env := range d.Config() { 		driverCfg[env] = os.Getenv(env) 	}+	if driverCfg["CLEANUP_CONTAINERS"] != "true" && driverCfg["CLEANUP_CONTAINERS"] != "false" {

 Copying descriptor sha256:a59a4e74d9cc89e4e75dfb2cc7ea5c108e4236ba6231b53081a9e2 Pushed successfully, with digest "sha256:6cabd752cb01d2efb9485225baf7fc26f4322c1f45f537f76c5eeb67ba8d83e0" ``` -**Note:** `cnab-to-oci` does not push images from your docker daemon image store.-Make sure all your invocation images are already present on a registry before pushing your bundle.+**Note:** if your images -invocation images as well as service images- are not present+on a registry `cnab-to-oci` will try to resolve them locally and push them from you

 func (o *parametersOptions) addFlags(flags *pflag.FlagSet) { 	flags.StringArrayVarP(&o.overrides, "set", "s", []string{}, "Override parameter value") } -type targetContextOptions struct {-	targetContext string+type installerContextOptions struct {+	installerContext string+}++func (o *installerContextOptions) addFlag(flags *pflag.FlagSet) {+	flags.StringVar(&o.installerContext, "installer-context", "", "Context on which the installer image is ran (default: <current-context>)") } -func (o *targetContextOptions) SetDefaultTargetContext(dockerCli command.Cli) {-	o.targetContext = getTargetContext(o.targetContext, dockerCli.CurrentContext())+func (o *installerContextOptions) setInstallerContext(dockerCli command.Cli) (command.Cli, error) {+	o.installerContext = getTargetContext(o.installerContext, dockerCli.CurrentContext())+	if o.installerContext != dockerCli.CurrentContext() {+		if _, err := dockerCli.ContextStore().GetMetadata(o.installerContext); err != nil {+			return nil, errors.Wrapf(err, "Unknown docker context %s", o.installerContext)+		}+		fmt.Fprintf(dockerCli.Out(), "Using context %q to run installer image", o.installerContext)+		cli, err := command.NewDockerCli()+		if err != nil {+			return nil, err+		}+		opts := flags.ClientOptions{+			Common: &flags.CommonOptions{+				Context:  o.installerContext,+				LogLevel: logrus.GetLevel().String(),+			},+			ConfigDir: config.Dir(),+		}+		if err = cli.Apply(+			command.WithInputStream(dockerCli.In()),+			command.WithOutputStream(dockerCli.Out()),+			command.WithErrorStream(dockerCli.Err())); err != nil {+			return nil, err+		}+		if err = cli.Initialize(&opts); err != nil {+			return nil, err+		}+		return cli, nil+	}+	return dockerCli, nil }  func getTargetContext(optstargetContext, currentContext string) string { 	var targetContext string 	switch { 	case optstargetContext != "": 		targetContext = optstargetContext-	case os.Getenv("DOCKER_TARGET_CONTEXT") != "":-		targetContext = os.Getenv("DOCKER_TARGET_CONTEXT")+	case os.Getenv("INSTALLER_TARGET_CONTEXT") != "":

 A CNAB indicates that it supports those actions by including them in its custom - `io.cnab.dry-run` (with `stateless`: true and `modifies`: false): execute the installation in a dry-run mode, allowing to see what would happen with the given set of parameter values. - `io.cnab.help` (with `stateless`: true and `modifies`: false): print an help message to the standard output. Implementations MAY print different messages depending on the parameters values passed to the invocation image. - `io.cnab.log` (with `stateless`: false and `modifies`: false): print logs of the installed system to the standard output.-- `io.cnab.status` (with `stateless`: false and `modifies`: false): print a human readable status message to the standard output.-- `io.cnab.status+json` (with `stateless`: false and `modifies`: false): print a json payload describing the detailed status as in the example below ([here](schema/status.schema.json) is the JSON schema for this):

 func prepareCustomAction(actionName string, dockerCli command.Cli, appname strin 	if err != nil { 		return nil, nil, nil, err 	}-	bundle, ref, err := cnab.ResolveBundle(dockerCli, bundleStore, appname)+	bundle, ref, err := cnab.GetBundle(dockerCli, bundleStore, appname) 	if err != nil {+		if strings.HasSuffix(appname, ".dockerapp") {

 func testRenderApp(appPath string, env ...string) func(*testing.T) { 		dir := fs.NewDir(t, "") 		defer dir.Remove() +		// Build the App+		cmd.Command = dockerCli.Command("app", "build", ".", "--folder", filepath.Join(appPath, "my.dockerapp"), "--tag", "a-simple-tag", "--no-resolve-image")+		res := icmd.RunCmd(cmd).Assert(t, icmd.Success)+		fmt.Println(res.Combined())

 func fixupPlatforms(ctx context.Context, 	return nil } -func fixupBaseImage(ctx context.Context, baseImage *bundle.BaseImage, cfg fixupConfig) (imageFixupInfo, error) {+func fixupBaseImage(ctx context.Context, name string, baseImage *bundle.BaseImage, cfg fixupConfig) (imageFixupInfo, bool, error) { 	// Check image references 	if err := checkBaseImage(baseImage); err != nil {-		return imageFixupInfo{}, fmt.Errorf("invalid image %q: %s", baseImage.Image, err)+		return imageFixupInfo{}, false, fmt.Errorf("invalid image %q for service %q: %s", baseImage.Image, name, err) 	} 	targetRepoOnly, err := reference.ParseNormalizedNamed(cfg.targetRef.Name()) 	if err != nil {-		return imageFixupInfo{}, err-	}-	sourceImageRef, err := reference.ParseNormalizedNamed(baseImage.Image)-	if err != nil {-		return imageFixupInfo{}, fmt.Errorf("%q is not a valid image reference for %q: %s", baseImage.Image, cfg.targetRef, err)+		return imageFixupInfo{}, false, err 	}-	sourceImageRef = reference.TagNameOnly(sourceImageRef) -	// Try to fetch the image descriptor-	_, descriptor, err := cfg.resolver.Resolve(ctx, sourceImageRef.String())-	if err != nil {-		if cfg.pushImages {-			descriptor, err = pushImageToTarget(ctx, baseImage, cfg)-			if err != nil {-				return imageFixupInfo{}, err+	var descriptor ocischemav1.Descriptor

+# Version of the application+version: 0.1.0+# Name of the application+name: build-demo+# A short description of the application+description: +# List of application maintainers with name and email for each+maintainers:+  - name: chris

 func (f *mockFetcher) Fetch(ctx context.Context, desc ocischemav1.Descriptor) (i 	f.indexBuffers = f.indexBuffers[1:] 	return rc, nil }++type mockReadCloser struct {+}++func (rc mockReadCloser) Read(p []byte) (n int, err error) {+	return 0, io.EOF+}++func (rc mockReadCloser) Close() error {+	return nil+}++type mockImageAPIClient struct {+}++func newMockImageAPIClient() *mockImageAPIClient {

 func fixupImage(ctx context.Context, baseImage *bundle.BaseImage, relocationMap 		} 	} +	if pushed {+		notifyEvent(FixupEventTypeCopyImageEnd, "Image has been pushed for service"+name, nil)

+package commands++import (+	"fmt"+	"os"+	"strings"++	"github.com/deislabs/cnab-go/action"+	"github.com/docker/app/internal"+	"github.com/docker/app/internal/cnab"+	"github.com/docker/app/internal/inspect"+	"github.com/docker/cli/cli"+	"github.com/docker/cli/cli/command"+	"github.com/spf13/cobra"+)++type inspectOptions struct {+	credentialOptions+	pretty       bool+	orchestrator string+}++func inspectCmd(dockerCli command.Cli) *cobra.Command {+	var opts inspectOptions+	cmd := &cobra.Command{+		Use:   "inspect [APP_NAME] [OPTIONS]",+		Short: "Shows installation and application metadata, parameters and the containers list of a running application",+		Example: `$ docker app inspect my-installed-app+$ docker app inspect my-app:1.0.0`,

+package commands++import (+	"fmt"+	"os"+	"strings"++	"github.com/deislabs/cnab-go/action"+	"github.com/docker/app/internal"+	"github.com/docker/app/internal/cnab"+	"github.com/docker/app/internal/inspect"+	"github.com/docker/cli/cli"+	"github.com/docker/cli/cli/command"+	"github.com/spf13/cobra"+)++type inspectOptions struct {+	credentialOptions+	pretty       bool+	orchestrator string+}++func inspectCmd(dockerCli command.Cli) *cobra.Command {+	var opts inspectOptions+	cmd := &cobra.Command{+		Use:   "inspect [APP_NAME] [OPTIONS]",+		Short: "Shows installation and application metadata, parameters and the containers list of a running application",+		Example: `$ docker app inspect my-installed-app

+package commands++import (+	"fmt"+	"os"+	"strings"++	"github.com/deislabs/cnab-go/action"+	"github.com/docker/app/internal"+	"github.com/docker/app/internal/cnab"+	"github.com/docker/app/internal/inspect"+	"github.com/docker/cli/cli"+	"github.com/docker/cli/cli/command"+	"github.com/spf13/cobra"+)++type inspectOptions struct {+	credentialOptions+	pretty       bool+	orchestrator string+}++func inspectCmd(dockerCli command.Cli) *cobra.Command {+	var opts inspectOptions+	cmd := &cobra.Command{+		Use:   "inspect [APP_NAME] [OPTIONS]",