In my previous post I gave a brief introduction about what is Openshift (now OKD) and how we could easily deploy Gitea. Now we will focus on building and deploying java applications using the "source2image" (S2I) strategy.
But what is this S2I?
According to the S2I project site:
Source-to-Image (S2I) is a toolkit and workflow for building reproducible Docker images from source code. S2I produces ready-to-run images by injecting source code into a Docker container and letting the container prepare that source code for execution. By creating self-assembling builder images, you can version and control your build environments exactly like you use Docker images to version your runtime environments.
What will happen in practice is that Openshift will take your project's source, combine it with a builder docker image and generate the final runtime image used to run the application.
Preparing the development environment
To run our development environment, we will use minishift to create an openshift cluster. Use the commands below to download and install minishift (if you are using linux):
MINISHIFT_VERSION=1.22.0 MINISHIFT_URL=https://github.com/minishift/minishift/releases/download/v$MINISHIFT_VERSION/minishift-$MINISHIFT_VERSION-linux-amd64.tgz curl -L -s -o /tmp/minishift.tgz $MINISHIFT_URL tar -C /tmp --wildcards -x */minishift --strip 1 -zf /tmp/minishift.tgz sudo install /tmp/minishift /usr/local/bin/minishift
With minishift installed, we can configure and start it (which may take several minutes):
# change values according to your workstation MINISHIFT_VM_DRIVER=virtualbox MINISHIFT_MEMORY=8G MINISHIFT_CPUS=4 MINISHIFT_DISK_SIZE=100G # configure minishift minishift config set vm-driver $MINISHIFT_VM_DRIVER minishift config set memory $MINISHIFT_MEMORY minishift config set cpus $MINISHIFT_CPUS minishift config set disk-size $MINISHIFT_DISK_SIZE minishift start
To interact with Openshift, we need to download the
oc command line tool, but with minishift we can use the bundled one, just execute the following:
eval $(minishift oc-env)
Then we login to openshift:
oc login 192.168.99.100:8443 -u admin # use 'admin' as password
Deploying the application
Now that we have minishift up and running, we can start deploying some application. Let's start with a django example application.
But first, let's create the project:
oc new-project django-example --display-name 'Django Example'
It will print something like this
Now using project "django-example" on server "https://192.168.99.100:8443". You can add applications to this project with the 'new-app' command. For example, try: oc new-app centos/ruby-22-centos7~https://github.com/openshift/ruby-ex.git to build a new example application in Ruby.
(Do not worry with the message about a ruby application, we are actually deploying a python application ;)
A project is the openshift terminology to a namespace, a place to group related resources and define access rules to these resources. For example, we could allow user "snake" to view our "django-example" project, user "rattlesnake" to view and edit (trigger builds and deploys, etc.) and not give any access to user "badger".
With the project created, we can create the application:
oc new-app python:3.6~https://github.com/sclorg/django-ex.git
You might be asking "what is going on?". Well, we are telling openshift to take the
python:3.6 image and combine it with the source code available at https://github.com/sclorg/django-ex.git. The syntax is "image"~"source".
But be careful! The
python:3.6 is not the official python image from docker hub! It is instead from centos/python-36-centos7 and was imported to the openshift integrated registry! It is an S2I image to build and run python projects! You can view other images using the command
oc get imagestream -n openshift
The output of the
oc new-app will have some information about the application, with the following at the end:
--> Success Build scheduled, use 'oc logs -f bc/django-ex' to track its progress. Application is not exposed. You can expose services to the outside world by executing one or more of the commands below: 'oc expose svc/django-ex' Run 'oc status' to view your app.
The suggested command
oc expose svc/django-ex will do something very important: it will expose a Service (a Kubernetes Service) to external traffic through a Route. The Route is very similar to a Service, but will handle external requests that matches a specific hostname and can also handle encryption (https).
Let's expose our application:
oc expose svc/django-ex
Unlike previous commands, exposing a service does not produce much output, so let's list the available routes to get the one we just created:
oc get routes
Which will output:
NAME HOST/PORT PATH SERVICES PORT TERMINATION WILDCARD django-ex django-ex-django-example.192.168.99.100.nip.io django-ex 8080-tcp None
As we can see, the route listens for the hostname
nip.io is a special service service that will redirect requests to the ip address contained in the hostname itself, is this case, 192.168.99.100, the ip address of the minishift vm.
Accessing the route address will show the following screen:
Openshift web console
Openshift also has a very nice web console accessible at [https://192.168.99.100:8443/console]. Just login with the same credentials we used before ("admin" for both username and password).
Opening the link to our project on the right will take us to the following page:
It is the project dashboard where we have an overview of the project, the applications deployed, routes, container status, etc. We can even scale the container!
The web console has lots of featues, even though some actions still require using the cli, like creating a service by exposing the Deployment.
This is it for now. Next time we will get into the web console.