Docker simplifies software delivery by making it easy to build and share images that contain your application’s entire environment, or application operating system.

Your application typically require a specific version of operating system, application server, JDK, database server, may require to tune the configuration files, and similarly multiple other dependencies. The application may need binding to specific ports and certain amount of memory. The components and configuration together required to run your application is what is referred to as application operating system.

You can certainly provide an installation script that will download and install these components. Docker simplifies this process by allowing to create an image that contains your application and infrastructure together, managed as one component. These images are then used to create Docker containers which run on the container virtualization platform, provided by Docker.

. *Faster delivery of your applications*: Docker helps you with the development lifecycle.

Docker allows you to develop on local containers that contain your applications

and services. It can then integrate into a continuous integration and

deployment workflow.

+

For example, you write code locally and share the development stack

via Docker with colleagues. When everybody is ready, you push the

code and the stack you all are developing onto a test environment

and execute any required tests.

+

From the testing environment, you can then push the Docker images

into production and deploy your code.

+

. *Deploying and scaling more easily*: Docker's container-based platform allows for portable workloads. Docker containers can run on a developer's local host, on physical

or virtual machines in a data center, or in the Cloud.

+

Docker's portability and lightweight nature also make dynamically managing workloads easy. You can use Docker to quickly scale up or tear down applications and services. Docker is so fast, that scaling can be near real time.

Docker is an open source container virtualization platform.

Docker has three main components:

. __Images__ are *build component* of Docker and a read-only template of application operating system.

. __Containers__ are *run component* of Docker, and created from, images.Containers can be run, started, stopped, moved, and deleted.

. Images are stored, shared, and managed in a __registry__, the *distribution component* of Docker. The publically available registry is known as Docker Hub.

In order for these three components to work together, there is *Docker Daemon* that runs on a host machine and does the heavy lifting of building, running, and distributing Docker containers. In addition, there is *Client* that is a Docker binary which accepts commands from the user and communicates back and forth with the daemon.

Client communicates with Daemon, either co-located on the same host, or on a different host. It requests the Daemon to pull an image from the repository using `pull` command. The Daemon then downloads the image from Docker Hub, or whatever registry is configured. Multiple images can be downloaded from the registry and installed on Daemon host. Images are run using `run` command to create containers on demand.

We've already seen that Docker images are read-only templates from which Docker containers are launched. Each image consists of a series of layers. Docker makes use of union file systems to combine these layers into a single image. Union file systems allow files and directories of separate file systems, known as branches, to be transparently overlaid, forming a single coherent file system.

One of the reasons Docker is so lightweight is because of these layers. When you change a Docker image—for example, update an application to a new version— a new layer gets built. Thus, rather than replacing the whole image or entirely rebuilding, as you may do with a virtual machine, only that layer is added or updated. Now you don't need to distribute a whole new image, just the update, making distributing Docker images faster and simpler.

Every image starts from a base image, for example `ubuntu`, a base Ubuntu image, or `fedora`, a base Fedora image. You can also use images of your own as the basis for a new image, for example if you have a base Apache image you could use this as the base of all your web application images.

NOTE: By default, Docker obtains these base images from Docker Hub.

Docker images are then built from these base images using a simple, descriptive set of steps we call instructions. Each instruction creates a new layer in our image. Instructions include actions like:

. Run a command.

. Add a file or directory.

. Create an environment variable.

. What process to run when launching a container from this image.

These instructions are stored in a file called a Dockerfile. Docker reads this Dockerfile when you request a build of an image, executes the instructions, and returns a final image.

A container consists of an operating system, user-added files, and meta-data. As we've seen, each container is built from an image. That image tells Docker what the container holds, what process to run when the container is launched, and a variety of other configuration data. The Docker image is read-only. When Docker runs a container from an image, it adds a read-write layer on top of the image (using a union file system as we saw earlier) in which your application can then run.

The client communicates with the demon process on your host and let's you work with images and containers.

Check if your client is working using the following command:

The most important options you'll be using frequently are:

. `run` - runs a container

. `ps`- lists containers

. `stop` - stops a container

Get a full list of available commands with

[source, text]

docker

Docker Compose script is only downloadable for OSX and Linux.

TODO: What are the exact steps to get it running on Windows?

Multiple containers, as in <<JavaEE_Application_Docker_Cluster>> can be easily started using Docker Compose, or Compose for short.

If you have some additional time, you can take this part of the lab:

http://blog.arungupta.me/docker-compose-orchestrate-containers-techtip77/

The Docker tooling is aimed at providing at minimum the same basic level features as the command-line interface, but also provide some advantages by having access to a full fledged UI.

### Install Docker Tools Plugins

As this is still in early access stage, you will have to install it first:

. Download and Install https://devstudio.redhat.com/9.0/snapshots/builds/devstudio.product_master/latest/installer/[JBoss Developer Studio 9.0 Nightly], take defaults through out the installation.

+

Alternatively, download http://www.eclipse.org/downloads/index-developer-default.php[Eclipse Mars latest build] and configure JBoss Tools plugin from the update site http://download.jboss.org/jbosstools/updates/nightly/mars/.

+

. Open JBoss Developer Studio 9.0 Nightly

. Add a new site using the menu items: ``Help'' > ``Install New Software...'' > ``Add...''. Specify the ``Name:'' as ``Docker Nightly'' and ``Location:'' as http://download.eclipse.org/linuxtools/updates-docker-nightly/.

+

.Add Docker Tooling To JBoss Developer Studio

+

. Expand Linux Tools, select ``Docker Client'' and ``Docker Tooling''.

. Click on ``Next >'', ``Next >'', accept the terms of the license agreement, and click on ``Finish''. This will complete the installation of plugins.

. Use the menu ``Window'', ``Show View'', ``Other...''. Type ``docker'' to see the output as:

+

+

. Select ``Docker Explorer'' to open Docker Explorer.

+

+

. Click on the link in this window to create a connection to Docker Host. Specify the settings as shown:

+

.Docker Explorer

+

Make sure to get IP address of the Docker Host as:

+

[source, text]

docker-machine ip lab

Also, make sure to specify the correct directory for `.docker` on your machine.

+

. Click on ``Test Connection'' to check the connection. This should show the output as:

+

.Docker Explorer

+

Click on ``OK'' and ``Finish'' to exit out of the wizard.

+

. Docker Explorer itself is a tree view that handles multiple connections and provides users with quick overview of the existing images and containers.

+

.Docker Explorer Tree View

+

. Customize the view by clicking on the arrow in toolbar:

+

.Docker Explorer Customize View

+

Built-in filters can show/hide intermediate and `dangling' images, as well as stopped containers.

+

.Docker Explorer Customize View Wizard

### Docker Images

The Docker Images view lists all images in the Docker host selected in the Docker Explorer view. This view allows user to manage images, including:

. Pull/push images from/to the Docker Hub Registry (other registries will be supported as well, https://bugs.eclipse.org/bugs/show_bug.cgi?id=469306[#469306])

. Build images from a Dockerfile

. Create a container from an image

Lets take a look at it.

. Use the menu ``Window'', ``Show View'', ``Other...'', select ``Docker Images''. It shows the list of images on Docker Host:

+

.Docker Images View

+

. Right-click on the image ending with ``wildfly:latest'' and click on the green arrow in the toolbar. This will show the following wizard:

+

.Docker Run Container Wizard

+

By default, all exports ports from the image are mapped to random ports on the host interface. This setting can be changed by unselecting the first checkbox and specify exact port mapping.

+

Click on ``Finish'' to start the container.

+

. When the container is started, all logs are streamed into Eclipse Console:

+

.Docker Container Logs

### Docker Containers

Docker Containers view lets the user manage the containers. The view toolbar provides commands to start, stop, pause, unpause, display the logs and kill containers.

. Use the menu ``Window'', ``Show View'', ``Other...'', select ``Docker Containers''. It shows the list of running containers on Docker Host:

+

.Docker Containers View

+

. Pause the container by clicking on the ``pause'' button in the toolbar (https://bugs.eclipse.org/bugs/show_bug.cgi?id=469310[#469310]). Show the complete list of containers by clicking on the ``View Menu'', ``Show all containers''.

+

.All Docker Containers

+

. Select the paused container, and click on the green arrow in the toolbar to restart the container.

. Right-click on any running container and select ``Display Log'' to view the log for this container.

+

.Eclipse Properties View

TODO: Users can also attach an Eclipse console to a running Docker container to follow the logs and use the STDIN to interact with it.

### Information and Inspect on Images and Containers

Eclipse Properties view is used to provide more information about the containers and images.

. Just open the Properties View and click on a Connection, Container, or Image in any of the Docker Explorer View, Docker Containers View, or Docker Images View. This will fill in data in the Properties view.

+

Info view is shown as:

+

.Docker Container Properties View Info

+

Inspect view is shown as:

+

.Docker Container Properties View Inspect

http://blog.jetbrains.com/idea/2015/03/docker-support-in-intellij-idea-14-1/

https://github.com/javaee-samples/javaee7-hol[Java EE 7 Hands-on Lab] has been delivered all around the world and is a pretty standard application that shows design patterns and anti-patterns for a typical Java EE 7 application.

Pull the Docker image that contains WildFly and pre-built Java EE 7 application WAR file as shown:

The javaee7-hol link:https://github.com/arun-gupta/docker-images/blob/master/javaee7-hol/Dockerfile[Dockerfile] is based on `jboss/wildfly` and adds the movieplex7 application as war file.

Run it as:

See the application in action at http://dockerhost:8080/movieplex7/.

Only two changes are required to the standard `jboss/wildfly` image:

. Start WildFly in full platform:

+

[source, text]

CMD ["/opt/jboss/wildfly/bin/standalone.sh", "-c", "standalone-full.xml", "-b", "0.0.0.0"]

. WAR file is copied to `standalone/deployments` directory as:

+

[source, text]

RUN curl -L https://github.com/javaee-samples/javaee7-hol/blob/jrebel/solution/movieplex7-1.0-SNAPSHOT.war?raw=true -o /opt/jboss/wildfly/standalone/deployments/movieplex7-1.0-SNAPSHOT.war

Machine makes it really easy to create Docker hosts on your computer, on cloud providers and inside your own data center. It creates servers, installs Docker on them, then configures the Docker client to talk to them.

Once your Docker host has been created, it then has a number of commands for managing them:

. Starting, stopping, restarting

. Upgrading Docker

. Configuring the Docker client to talk to your host

You used Docker Machine already during the attendee setup. We won't need it too much further on. But if you need to create hosts, it's a very handy tool to know about. From now on we're mostly going to use the docker client.

Find out more about the details at the link:https://docs.docker.com/machine/[Official Docker Machine Website]

Check if docker machine is working using the following command:

http://blog.arungupta.me/javaee-docker-maven-plugin/