Getting started with Photon OS and vSphere Integrated Containers

There has been a lot of news recently about the availability of vSphere Integrated Containers (VIC) v0.1 on GitHub. VMware has being doing a lot of work around containers, container management and the whole area of cloud native applications over the last while. While many of these projects cannot be discussed publicly there are two projects that I am going to look at here :

• Photon OS – a minimal Linux container host designed to boot extremely quickly on VMware platforms.
• vSphere Integrated Containers – a way to deploy containers on vSphere. This allows developers to create applications using containers, but have the vSphere administrator manage the required resources needed for these containers.

As I said, this is by no means the limit of the work that is going on. Possibly the best write-up I have seen discussing the various work in progress in this one here on the Next Platform site.

I will admit that I’m not that well versed in containers or docker, but I will say that I found Nigel Poulton’s Docker Deep Dive on PluralSight very informative. If you need a primer on containers, I would highly recommend watching this.

So what I am going to this in this post? In this post, I will walk through the deployment of the Photon OS, and then deploy VIC afterwards. You can then see for yourself how containers can be deployed on vSphere, and perhaps managed by a vSphere administrator while the developer just worries about creating the app, and doesn’t have to worry about the underlying infrastructure.

Part 1: Deploy Photon OS

There are three Photon OS distribution formats available for vSphere; a minimal ISO, a full ISO and an OVA (appliance). You can get them by clicking here. Of course, the OVA is the simplest way to get started. But you might like to use the full ISO method, which is the approach I took. This simply means creating a Linux VM, attaching the ISO to it, and going through the installation.Use the following guidelines:

• Guest OS Family: “Linux”
• Guest OS Version: “Other 3.x Linux (64-bit)”.
• 2 vCPU
• 2GB Memory (minimum)
• 20GB Disk (minimum), recommend 40GB for building VIC later
• Network interface with internet access

Once deployed, not that SSH is not enabled by default for root, so you will have to enable that too via the /etc/ssh/sshd_config file. Login as root (default password is changeme), change the root password when prompted to do so, uncomment the “PermitRootLogin” entry, and restart sshd as follows:

root [ ~ ]# systemctl restart sshd

Docker also needs to be started and enabled:

root [ ~ ]# systemctl start docker
root [ ~ ]# systemctl enable docker

And that’s it. You can now start to run docker commands, deploy containers and run some cloud native applications. The example provided in the Photon OS docs in Nginx:

root [ ~ ]# docker run -d -p 80:80 vmwarecna/nginx

You can now point a browser at that container, and verify Nginx is up and running. That was pretty painless, right? Now you are ready to deploy VIC using this Photon OS.

Part 2: Deploy vSphere Integrated Containers (VIC) v0.1

Now there are two ways to do this. The first method is to pull down a pre-compiled, ready-to-run version , and the second method is to build it yourself. If you are using the appliance approach, or the minimal ISO, a lot of commands and tools are missing. You will need to install the missing commands, such as git, wget, tar, gcc, etc. My good friend and colleague Bjoern has written a good post on how to get started with the ready-to-run version here. I am going to take another approach and build VIC myself.

To do that, we just do a “git clone” of VIC. If the git binaries are not installed, you will need to add them. To do that, run the following command in the Photon OS:

root [ ~ ]# tdnf install git
Installing:
 perl-DBIx-Simple       noarch  1.35-1.ph1tp2
 perl-DBD-SQLite        x86_64  1.46-1.ph1tp2
 perl-YAML      noarch  1.14-1.ph1tp2
 perl-DBI       x86_64  1.633-1.ph1tp2
 perl   x86_64  5.18.2-2.ph1tp2
 git    x86_64  2.1.2-1.ph1tp2
Is this ok [y/N]:y
Downloading 7592028.00 of 7592028.00
Downloading 17943120.00 of 17943120.00
Downloading 800663.00 of 800663.00
Downloading 67718.00 of 67718.00
Downloading 2081562.00 of 2081562.00
Downloading 38049.00 of 38049.00
Testing transaction
Running transaction

Complete!
root [ ~ ]#

Now we have all the bits we need to build. One thing to be aware of is the disk size. I was getting very close to using up all of the available space when using the appliance. This is why I would recommend folks to pull down the full ISO, create a Linux VM with a large enough VMDK/plenty of disk space, and install from there. Another option is to add another VMDK to the appliance, create a filesystem on it, mount it, and then use that for the build, but as I said, the appliance is missing a lot of tools, so will be more challenging.

Anyways, without further ado, here are the steps:

root [ ~ ]# git clone https://github.com/vmware/vic
Cloning into 'vic'...
remote: Counting objects: 8922, done.
remote: Compressing objects: 100% (39/39), done.
remote: Total 8922 (delta 7), reused 0 (delta 0), pack-reused 8881
Receiving objects: 100% (8922/8922), 12.70 MiB | 4.79 MiB/s, done.
Resolving deltas: 100% (2911/2911), done.
Checking connectivity... done.

Change directory to /vic, and start the compilation:

root [ ~ ]# cd vic
root [ ~/vic ]# docker run -v $(pwd):/go/src/github.com/vmware/vic \
-w /go/src/github.com/vmware/vic golang:1.6 make all
Unable to find image 'golang:1.6' locally
1.6: Pulling from library/golang
.
.
<<-- this can take some time, and there is a lot of output -->>
.
.
Making bootstrap iso
Constructing initramfs archive
364232 blocks
xorriso 1.3.2 : RockRidge filesystem manipulator, libburnia project.

Drive current: -dev '/go/src/github.com/vmware/vic/bin/bootstrap.iso'
Media current: stdio file, overwriteable
Media status : is blank
Media summary: 0 sessions, 0 data blocks, 0 data, 14.1g free
xorriso : UPDATE : 7 files added in 1 seconds
Added to ISO image: directory '/'='/tmp/tmp.6lB4qQGr7I/bootfs'
xorriso : UPDATE : Writing:       8192s   23.9%   fifo 100%  buf  50%
xorriso : UPDATE : Writing:       8192s   23.9%   fifo 100%  buf  50%
ISO image produced: 34162 sectors
Written to medium : 34336 sectors at LBA 32
Writing to '/go/src/github.com/vmware/vic/bin/bootstrap.iso' completed 
successfully.

Building installer
root [ ~/vic ]#

OK. We have now successfully built VIC. Let’s go ahead and deploy a container on vSphere.

root [ ~/vic ]# cd bin
root [ ~/vic/bin ]# ls
appliance-staging.tgz  bootstrap.iso         install.sh         ...
appliance.iso          docker-engine-server  iso-base.tgz       ...
bootstrap-staging.tgz  imagec                port-layer-server  ...

The command we are interested in is install.sh. This creates our containers. What we need to do is to provide it with a target which is the login credentials and IP address of an ESXi host. We also need to provide a target datastore, and the name of the container (vic-01). the goal here is to deploy a container on an ESXi host:

 root [ ~/vic/bin ]# ./install.sh -g -t 'root:VMware123!@10.27.51.5' \
 -i vsanDatastore vic-01
# Generating certificate/key pair - private key in vic-01-key.pem
# Logging into the target
./install.sh: line 184: govc: command not found

Oops! I missed a step. We need to install govc (or go VC). govc is a vSphere CLI built on top of govmomi. Let’s sort that out next.I am going to place it in its own directory, and set up the GOPATH variable to point to it. You should consider putting this in .bash_profile of the root user so that it persists. The important step is the ‘go get’:

root [ ~/vic ]# pwd
/root/vic
root [ ~/vic ]# mkdir govmw
root [ ~/vic ]# cd govmw/
root [ ~/vic/govmw ]# pwd
/root/vic/govmw
root [ ~/vic/govmw ]# export GOPATH=/root/vic/govmw
root [ ~/vic/govmw ]# PATH=$PATH:$GOPATH/bin
root [ ~/vic/govmw ]# go get github.com/vmware/govmomi/govc
root [ ~/vic/govmw ]# ls
bin  pkg  src
root [ ~/vic/govmw ]# ls bin/
govc
root [ ~/vic/govmw ]#

OK, now we have govc, lets try once more to deploy a container:

root [ ~/vic/bin ]# ./install.sh -g -t 'root:VMware123!@10.27.51.5' \
-i vsanDatastore vic-01
# Generating certificate/key pair - private key in vic-01-key.pem
# Logging into the target
# Uploading ISOs
[06-04-16 12:46:05] Uploading... OK
[06-04-16 12:46:07] Uploading... OK
# Creating vSwitch
# Creating Portgroup
# Creating the Virtual Container Host appliance
# Adding network interfaces
# Setting component configuration
# Configuring TLS server
# Powering on the Virtual Container Host
# Setting network identities
# Waiting for IP information
#
# SSH to appliance (default=root:password)
# root@10.27.51.103
#
# Log server:
# https://10.27.51.103:2378
#
# Connect to docker:
docker -H 10.27.51.103:2376 --tls --tlscert='vic-01-cert.pem' \
--tlskey='vic-01-key.pem'
 
DOCKER_OPTS="--tls --tlscert='vic-01-cert.pem' \
--tlskey='vic-01-key.pem'"
DOCKER_HOST=10.27.51.103:2376
root [ ~/vic/bin ]#

That looks much better. There are even some docker commands provided which allow us to query the containers. Now, a lot of the docker calls have not been implemented, and will fail with errors similar to “Error response from daemon: vSphere Integrated Containers does not implement container.ContainerStop”.

root [ ~/vic/bin ]# docker -H 10.27.51.104:2376 --tls \
--tlscert='vic-02-cert.pem' --tlskey='vic-02-key.pem' info
Containers: 0
Images: 0
Storage Driver: Portlayer Storage
CPUs: 0
Total Memory: 0 B
Name: VIC
WARNING: No memory limit support
WARNING: No swap limit support
WARNING: IPv4 forwarding is disabled.
WARNING: bridge-nf-call-iptables is disabled
WARNING: bridge-nf-call-ip6tables is disabled

root [ ~/vic/bin ]# docker -H 10.27.51.104:2376 --tls \
--tlscert='vic-02-cert.pem' --tlskey='vic-02-key.pem' version
Client:
 Version:      1.8.1
 API version:  1.20
 Go version:   go1.4.2
 Git commit:   d12ea79
 Built:        Thu Aug 13 02:49:29 UTC 2015
 OS/Arch:      linux/amd64
Server:
 Version:      0.0.1
 API version:  1.23
 Go version:   go1.6
 Git commit:   -
 Built:        -
 OS/Arch:      linux/amd64
 Experimental: true
root [ ~/vic/bin ]#

Let’s have a look at this container in vSphere:

And that is basically it: containers with applications being created by the software developer, but using/consuming resources from vSphere and managed by the vSphere administrator. I know the majority of my readers are vSphere administrators. How does this approach to managing containers resonate with you folks?

Now, as you might suspect from a v0.1, these are the very first steps towards a far more integrated implementation. However, hopefully it gives you an idea of where we are going with this (it certainly helped me to understand). I’ve already seen some of this future integration and it looks really cool.

As you can see there are various ways to get started, and it is relatively painless. Why not give it a try?