This blog will show how a simple Java application can talk to a database using service discovery in DC/OS.

Why Service Discovery?

An application typically consist of multiple components such as an application server, a database, a web server, caching and messaging server. Typically, multiple replicas of each component would run based upon the needs of your application. Deploying this application using a container orchestration framework means that each replica would run as a container. So, an application is typically deployed as multi-container application.

Each container is assigned a unique IP address for its lifetime. But containers are ephemeral and may terminate and rescheduled on a different host by the orchestration framework. A container is typically assigned a different IP address in that case. This means an application deployed in application server cannot rely upon the IP address of the database. This is where service discovery is required.

So, multiple replicas of a component are assigned a logical name. For example, web for all the application server containers and db for all the database containers. Now, an application can talk to the database containers using the logical service name. This allows the database containers to be rescheduled anywhere in the cluster, and also scale up and down dynamically.

Let’s see how this can be accomplished in DC/OS with a single instance of application server and database server. This blog will use WildFly for application server and Couchbase for database.

Couchbase Cluster on Mesos with DC/OS provide more details on how to setup a Couchbase cluster on DC/OS.

This blog will use the following main steps:

• Setup DC/OS Cluster
• Marathon application definition
• Deploy the application

The complete source code used in this blog is at github.com/arun-gupta/dcos-java-database.

Many thanks to @unterstein for creating the Maven plugin and helping me understand the inner workings of DC/OS.

Setup DC/OS Cluster

DC/OS cluster can be easily created using the CloudFormation template. Detailed instructions, including system requirements and screenshots and setup, are available at Installing DC/OS on AWS.

CloudFormation output looks as shown:

Note down the value shown for the keys DnsAddress and PublicSlaveDnsAddress. The value of the first key can be used to access DC/OS GUI and looks like:

Configure DC/OS CLI as explained in CLI. In short, the following commands are used:

• dcos config set core.dcos_url http://${DnsAddress} Replace ${DnsAddress} with the corresponding value from the CloudFormation output.
• dcos auth login
• dcos config show core.dcos_acs_token. If not already done, clone the repo from github.com/arun-gupta/dcos-java-database. Create a new file.dcos-token and copy the output from the command in this file.
• dcos package install marathon-lb

Marathon Application Definition

Marathon framework is used to schedule containers in DC/OS. A marathon application can be defined by providing an application definition.

As mentioned earlier, this blog will show how a simple Java application can talk to a database. We’ll use a Java EE application deployed in WildFly and use Couchbase as the database. The application definition looks like:

What are the key points in this application definition?

• Application has two containers: database and web. The web container has a dependency on the database container defined using dependencies attribute.
• database container uses arungupta/couchbase:travel Docker image. This image is created from github.com/arun-gupta/couchbase-javaee/tree/master/couchbase. It uses Couchbase base image and uses Couchbase REST API to pre-configure the database. A sample bucket is also loaded in the database as well.
• web container uses arungupta/wildfly-couchbase-javaee:travel image. This image is created from github.com/arun-gupta/couchbase-javaee/blob/master/Dockerfile. This is a Java EE 7 application bundled in WildFly. The app uses COUCHBASE_URI as an environment variable to connect to the Couchbase database. The value of this environment variable is configured to use DNS service discovery and is derived as explained in Virtual Networks.

Make sure to change the value of HAPROXY_0_VHOST to match the value of ${PublicSlaveDnsAddress} from CloudFormation output. The label HAPROXY_0_VHOST instructs Marathon-LB to expose the Docker container, the WildFly application server in our case, on the external load balancer with a virtual host. The 0 in the label key corresponds to the servicePort index, beginning from 0. If you had multiple servicePort definitions, you would iterate them as 0, 1, 2, and so on. Deploying an internally and externally load-balanced app with marathon-lb provide more details about how to configure marathon-lb.

Service Discovery and Load Balancing provide more details about service discovery and load balancing in DC/OS.

Deploy the Application using Maven

The application can be deployed using dcos-maven-plugin.

Plugin looks like:

Main points in this fragment are:

• Plugin version is 0.2. That indicates the plugin is still in early stages of development.
• dcosUrl is the value of ${DnsAddress} key from CloudFormation output. This address is used for deployment of the application.
• <deployable> element enables different types of deployment – app, group or pods. This element is a hint for the plugin and should likely go away in a future version as Marathon API consolidates. Follow #11 for more details.

Other details and configuration about the plugin are at dcos-maven-plugin.

Deploy the application:

The following output is shown:

Here are some of the updated output from DC/OS console.

First updated Services tab:

Two applications in the service:

Database application has one task:

Status of database task:

Logs from the database task:

It shows the output from Couchbase REST API for configuring the server.

Status of web task:

Logs from web task:

It shows that the Java EE application is deployed successfully.

Access the application:

The address is the value of the key ${PublicSlaveDnsAddress} from CloudFormation output. A formatted output, for example with jq, looks like:

That’s it!

As mentioned earlier, the complete source code used in this blog is at github.com/arun-gupta/dcos-java-database.

This blog showed how a simple Java application can talk to a database using service discovery in DC/OS.

For further information check out:

• DC/OS Docs
• Couchbase on Containers
• Couchbase Developer Portal
• Ask questions on Couchbase Forums or Stack Overflow
• Download Couchbase

Source: blog.couchbase.com/service-discovery-java-database-dcos/

Containers are meant to be ephemeral and so scale pretty well for stateless applications. Stateful containers, such as Couchbase, need to be treated differently. Managing Persistence for Docker Containers provide a great overview of how to manage persistence for stateful containers.

This blog will explain how to use Docker Volume Plugins and Portworx to create a stateful container.

Why Portworx?

Portworx is an easy-to-deploy container data services that provide persistence, replication, snapshots, encryption, secure RBAC and much more. Some of the benefits are:

1. Container granular volumes – Portworx can take multiple EBS volumes per host and aggregate the capacity and derive container granular virtual (soft) volumes per container.
2. Cross Availability Zone HA – Portworx will protect the data, at block level, across multiple compute instances across availability zones. As replication controllers restart pods on different nodes, the data will still be highly available on those nodes.
3. Support for enterprise data operations – Portworx implements container granular snapshots, class of service, tiering on top of the available physical volumes.
4. Ease of deployment and provisioning – Portworx itself is deployed as a container and integrated with the orchestration tools. DevOps can programmatically provision container granular storage with any property such as size, class of service, encryption key etc.

Setup AWS EC2 Instance

Portworx runs only on Linux or CoreOS. Setup an Ubuntu instance on AWS EC2:

1. Start Ubuntu 14.04 instance with m3.medium instance type. Make sure to add port 8091 to inbound security rules. This allows Couchbase Web Console to be accessible afterwards.
2. Login to the EC2 instance using the command: ssh -i ~/.ssh/arun-cb-west1.pem ubuntu@<public-ip>
3. Update the Ubuntu instance: sudo apt-get update
4. Install Docker: curl -sSL https://get.docker.com/ | sh. More detailed instructions are available at Get Docker for Ubuntu.
5. Enable non-root access for the docker command: sudo usermod -aG docker ubuntu
6. Logout from the EC2 instance and log back in

Create AWS EBS Volume

1. Create an EBS volume for 10GB using EC2 console as explained in docs.
2. Get the instance id from the EC2 console. Attach this volume to EC2 instance using this instance id, use the default device name /dev/sdf.


3. Use lsblk command in EC2 instance to verify that the volume is attached to the instance:
   
   NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT xvda 202:0 0 8G 0 disk └─xvda1 202:1 0 8G 0 part / xvdb 202:16 0 30G 0 disk /mnt xvdf 202:80 0 10G 0 disk

   1 2 3 4 5 6 7

   NAME    MAJ:MIN RM SIZE RO TYPE MOUNTPOINT xvda    202:0    0   8G  0 disk └─xvda1 202:1    0   8G  0 part / xvdb    202:16   0  30G  0 disk /mnt xvdf    202:80   0  10G  0 disk

Portworx Container

1. Physical storage makeup of each node, all the provisioned volumes in the cluster as well as their container mappings is stored in an etcd cluster. Start an etcd cluster:
   
   docker run -v \ /data/varlib/etcd \ -p 4001:4001 \ -d \ portworx/etcd:latest

   1 2 3 4 5 6 7

   docker run -v \   /data/varlib/etcd \   -p 4001:4001 \   -d \   portworx/etcd:latest

2. By default root mounted volumes are not allowed to be shared. Enable this using the command:
   
   sudo mount --make-shared /

   1 2 3

   sudo mount --make-shared /

   This is explained more at Ubuntu Configuration and Shared Mounts.
3. PX-Developer (px-dev) container on a server with Docker Engine turns that server into a scale-out storage node. PX-Enterprise, on the other hand, provides multi-cluster and multi-cloud support, where storage under management can be on-premise or in a public cloud like AWS.
   For this blog, we’ll start a px-dev container:
   
   docker run --restart=always --name px -d --net=host \ --privileged=true \ -v /run/docker/plugins:/run/docker/plugins \ -v /var/lib/osd:/var/lib/osd:shared \ -v /dev:/dev \ -v /etc/pwx:/etc/pwx \ -v /opt/pwx/bin:/export_bin:shared \ -v /var/run/docker.sock:/var/run/docker.sock \ -v /var/cores:/var/cores \ -v /usr/src:/usr/src \ --ipc=host \ portworx/px-dev -daemon -k etcd://localhost:4001 -c cluster1 -s /dev/xvdf

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   docker run --restart=always --name px -d --net=host \   --privileged=true                             \   -v /run/docker/plugins:/run/docker/plugins    \   -v /var/lib/osd:/var/lib/osd:shared           \   -v /dev:/dev                                  \   -v /etc/pwx:/etc/pwx                          \   -v /opt/pwx/bin:/export_bin:shared            \   -v /var/run/docker.sock:/var/run/docker.sock  \   -v /var/cores:/var/cores                      \   -v /usr/src:/usr/src                           \   --ipc=host                                    \   portworx/px-dev -daemon -k etcd://localhost:4001 -c cluster1 -s /dev/xvdf

   Complete details about this command are available at Run PX with Docker.
4. Look for logs using docker container logs -f px and watch out for the following statements:
   
   time="2017-02-16T05:33:26Z" level=info msg="Initialize the scheduler client and the scheduler watch" time="2017-02-16T05:33:26Z" level=info msg="Started a kvdb watch on key : scheduler/containers" time="2017-02-16T05:33:26Z" level=info msg="Started a kvdb watch on key : scheduler/volumes" time="2017-02-16T05:33:26Z" level=info msg="Started a kvdb watch on key : scheduler/nodes/list"

   1 2 3 4 5 6

   time="2017-02-16T05:33:26Z" level=info msg="Initialize the scheduler client and the scheduler watch" time="2017-02-16T05:33:26Z" level=info msg="Started a kvdb watch on key : scheduler/containers" time="2017-02-16T05:33:26Z" level=info msg="Started a kvdb watch on key : scheduler/volumes" time="2017-02-16T05:33:26Z" level=info msg="Started a kvdb watch on key : scheduler/nodes/list"

5. Check the status of attached volumes that are available to Portworx using sudo /opt/pwx/bin/pxctl status to see the output:
   
   Status: PX is operational Node ID: 679b79b1-f4c3-413e-a8e0-c527348647c9 IP: 172.31.25.21 Local Storage Pool: 1 pool Pool IO_Priority Size Used Status Zone Region 0 LOW 10 GiB 266 MiB Online a us-west-1 Local Storage Devices: 1 device Device Path Media Type Size Last-Scan 0:1 /dev/xvdf STORAGE_MEDIUM_SSD 10 GiB 16 Feb 17 05:33 UTC total - 10 GiB Cluster Summary Cluster ID: cluster1 Node IP: 172.31.25.21 - Capacity: 266 MiB/10 GiB Online (This node) Global Storage Pool Total Used : 266 MiB Total Capacity : 10 GiB

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   Status: PX is operational Node ID: 679b79b1-f4c3-413e-a8e0-c527348647c9     IP: 172.31.25.21     Local Storage Pool: 1 pool     Pool    IO_Priority    Size    Used    Status    Zone    Region     0    LOW        10 GiB    266 MiB    Online    a    us-west-1     Local Storage Devices: 1 device     Device    Path        Media Type        Size        Last-Scan     0:1    /dev/xvdf    STORAGE_MEDIUM_SSD    10 GiB        16 Feb 17 05:33 UTC     total            -            10 GiB Cluster Summary     Cluster ID: cluster1     Node IP: 172.31.25.21 - Capacity: 266 MiB/10 GiB Online (This node) Global Storage Pool     Total Used        :  266 MiB     Total Capacity    :  10 GiB

   It shows the total capacity available and used.

Docker Volume

1. Let’s create a Docker volume:
   
   docker volume create -d pxd -o size=10G -o fs=ext4 --name cbvol

   1 2 3

   docker volume create -d pxd -o size=10G -o fs=ext4 --name cbvol

   More details about this command are at Create Volumes with Docker.
2. Check the list of volumes available using docker volume ls command:
   
   DRIVER VOLUME NAME local 70f7b9a356df4c1f0c08e13a4e813f1ef3e174a91001f277a63b62d683a27159 pxd cbvol local f7bc5fa455a88638c106881f1bce98244b670e094d5fdc47917b53a88e46c073

   1 2 3 4 5 6

   DRIVER              VOLUME NAME local               70f7b9a356df4c1f0c08e13a4e813f1ef3e174a91001f277a63b62d683a27159 pxd                 cbvol local               f7bc5fa455a88638c106881f1bce98244b670e094d5fdc47917b53a88e46c073

   As shown, cbvol is created with pxd driver.

Couchbase with Portworx Volume

1. Create a Couchbase container using the Portworx volume:
   
   docker container run \ -d \ --name db \ -v cbvol:/opt/couchbase/var \ -p 8091-8094:8091-8094 \ -p 11210:11210 \ arungupta/couchbase

   1 2 3 4 5 6 7 8 9

   docker container run \   -d \   --name db \   -v cbvol:/opt/couchbase/var \   -p 8091-8094:8091-8094 \   -p 11210:11210 \   arungupta/couchbase

   Notice how /opt/couchbase/var where all Couchbase data is stored in the container is mapped to the cbvol volume on the host. This volume is mapped by Portworx.
2. Login to Couchbase Web Console at http://<public-ip>:8091, use the login Administrator and password as password.
3. Go to Data Buckets and create a new data bucket pwx:
   
4. In EC2 instance, see the list of containers:
   
   ubuntu@ip-172-31-25-21:~$ docker container ls CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 8ae763d9d53b arungupta/couchbase "/entrypoint.sh /o..." 5 minutes ago Up 5 minutes 0.0.0.0:8091-8094->8091-8094/tcp, 11207/tcp, 11211/tcp, 0.0.0.0:11210->11210/tcp, 18091-18093/tcp db 5423bcd9b426 portworx/px-dev "/docker-entry-poi..." 14 minutes ago Up 14 minutes px cf3c779a4459 portworx/etcd:latest "/entrypoint.sh /b..." 21 minutes ago Up 21 minutes 2379-2380/tcp, 7001/tcp, 0.0.0.0:4001->4001/tcp youthful_jepsen

   1 2 3 4 5 6 7

   ubuntu@ip-172-31-25-21:~$ docker container ls CONTAINER ID        IMAGE                  COMMAND                  CREATED             STATUS              PORTS                                                                                               NAMES 8ae763d9d53b        arungupta/couchbase    "/entrypoint.sh /o..."   5 minutes ago       Up 5 minutes        0.0.0.0:8091-8094->8091-8094/tcp, 11207/tcp, 11211/tcp, 0.0.0.0:11210->11210/tcp, 18091-18093/tcp   db 5423bcd9b426        portworx/px-dev        "/docker-entry-poi..."   14 minutes ago      Up 14 minutes                                                                                                           px cf3c779a4459        portworx/etcd:latest   "/entrypoint.sh /b..."   21 minutes ago      Up 21 minutes       2379-2380/tcp, 7001/tcp, 0.0.0.0:4001->4001/tcp                                                     youthful_jepsen

   etcd, px-dev and db containers are running.
5. Kill the db container:
   
   docker container rm -f db

   1 2 3

   docker container rm -f db

6. Restart the database container as:
   
   docker container run \ -d \ --name db \ -v cbvol:/opt/couchbase/var \ -p 8091-8094:8091-8094 \ -p 11210:11210 \ arungupta/couchbase

   1 2 3 4 5 6 7 8 9

   docker container run \   -d \   --name db \   -v cbvol:/opt/couchbase/var \   -p 8091-8094:8091-8094 \   -p 11210:11210 \   arungupta/couchbase

   Now, because cbvol is mapped to /opt/couchbase/var again, the data is preserved across restarts. This can be verified by accessing the Couchbase Web Consoleand checking on the pwx bucket created earlier.

Another interesting perspective is also at why database are not for containers?. Just because there is Docker, does not mean all your database needs should be Dockerized. But if you need to, then there are plenty of options and can be used in production-grade applications.

Want to learn more about running Couchbase in containers?

• Couchbase on Containers
• Couchbase Developer Portal
• @couchhasedev and @couchbase

Source: blog.couchbase.com/stateful-docker-containers-portworx-couchbase/

Couchbase Forums has a question Can’t use N1QL on docker-compose. This blog will show how to run Couchbase using Docker Compose and run a N1QL query.

What is Docker Compose?

Docker Compose allows you to define your multi-container application with all of its dependencies in a single file, then spin your application up in a single command.

Docker Compose introduced v3 in Docker 1.13. How do you know what version of Docker are you running?

docker version command gives you that information:

Couchbase Docker Compose File

Now if you see this version of Docker, then you can use the following Compose file:

In this Compose file:

• v3 version of Compose file. If you are using an older version of Docker, then you can consider using v2 version of Compose file.
• arungupta/couchbase Docker image is used to start Couchbase server.  This image is created as explained at github.com/arun-gupta/docker-images/tree/master/couchbase. It uses Couchbase REST API to pre-configure the Couchbase server.
• Ports 8091, 8092, 8093, 8094, 11210 are exposed.
• Only a single replica of Couchbase server is started.

Couchbase can be started in a couple of ways using this Compose file.

Couchbase using Docker Compose on Single Docker Host

If you want to start Couchbase on a single host (such as provisioned by Docker for Mac or a single Docker Machine), then use the command:

This will show the warning message but starts Couchbase server:

Check the status of started service using the command docker-compose ps:

All the exposed ports are shown and Couchbase is accessible at http://localhost:8091. Use the credentials Administrator/password to access the web console.

Now you can create buckets and connect from CBQ and run N1QL queries. For example:

Typically, you may be able to scale the services started by Docker Compose using docker-compose scale command. But this will not be possible in our case as the ports are exposed. Scaling a service will cause port conflict.

The container can be brought down using the command docker-compose down.

Couchbase using Docker Compose on Multi-host Swarm-mode Cluster

Docker allows multiple hosts to be configured in a cluster using Swarm-mode. This can be configured using the command docker swarm init.

Once the cluster is initialized, then the Compose file can be used to start the cluster:

It shows the output:

This creates a Docker service and the status can be seen using the command docker service ls:

Check the tasks/containers running inside the service using the command docker service ps couchbase_db:

Here again, you can connect to the Couchbase server and run N1QL queries:

The service, and thus the container running in the service, can be terminated using the command docker service couchbase_db.

Any more questions? Catch us on Couchbase Forums.

You may also consider running Couchbase Cluster using Docker or read more about Deploying Docker Services to Swarm.

Want to learn more about running Couchbase in containers?

• Couchbase on Containers
• Couchbase Developer Portal
• @couchhasedev and @couchbase

Source: blog.couchbase.com/couchbase-using-docker-compose/