Bailador is a light-weight route-based web application framework for Perl 6. Thanks to Gabor Szabo who has invited me to join the project and see how I can help the team.
I decided to make efforts in configuration management, deployment tasks. At the moment Bailador developers need help in this area.
Docker is quite popular way to distribute applications across teams, so I gave it it try. Welcome to bailador-docker-sparrowdo – a small project to help the Bailador developers to easy check latest changes in Baildor source code.
What can you do by using bailador-docker-sparrowdo:
* Build docker image with the sample Bailador application.
* Start the sample application.
* Update an existing docker image by picking up the latest changes from Bailador source code repository ( github ).
Let me show in more details how this could be done by using sparrowdo.
Build docker image
First of all you need to check out bailador-docker-sparrowdo and run `docker build` command:
$ git clone https://github.com/melezhik/bailador-docker-sparrowdo.git
$ cd bailador-docker-sparrowdo
$ docker build -t bailador .
It takes a few minutes to build the image. Under the hood it:
* Pulls alpine-perl6 base image with Alpine Linux and Perl6/zef pre installed, the image was created by Juan Julián Merelo Guervós.
* Installs sparrow/sparrowdo as it used as the configuration management tool for sample application.
Only a few instructions could be found at Dockerfile:
FROM jjmerelo/alpine-perl6
ENV PATH=/root/.rakudobrew/moar-nom/install/share/perl6/site/bin:$PATH
RUN apk add wget git curl bash build-base gcc perl-dev
RUN cpan App::cpanminus
RUN cpanm -q --notest https://github.com/melezhik/outthentic.git Sparrow
RUN zef install https://github.com/melezhik/sparrowdo.git
# ...
The rest of configuration to be done by sparrowdo itself by running `sparrowdo` command during the build process:
COPY sparrowfile /tmp/
RUN sparrowdo --local_mode --sparrowfile=/tmp/sparrowfile --no_sudo
Here is the content of sparrowdo scenario:
directory '/var/data';
bash 'zef install Path::Iterator';
bash 'zef install TAP::Harness';
bash 'zef install HTTP::MultiPartParser';
bash(q:to/HERE/);
set -e
cd /var/data/
if test -d /var/data/Bailador; then
cd Bailador
git pull
cd ../
else
git clone https://github.com/Bailador/Bailador.git
fi
HERE
bash "cd /var/data/Bailador && zef --depsonly install .";
bash "cd /var/data/Bailador && prove6 -l";
bash "cd /var/data/Bailador && zef install --/test --force .";
Right now it is simple enough, but the use of Sparrowdo gives me a freedom to create any sophisticated build scenarios in the future, which hardly could be expressed by using “only Dockerfile” approach.
Eventually, as new requirements come or new build scenarios need I will add more sparrowdo scenarios to effectively manage the build process.
Finally, I have added a few lines to the end of Dockerfile to copy sample Bailador application script and to declare the default entry point to launch the application:
COPY entrypoint.sh /tmp/
COPY example.p6w /tmp/
ENTRYPOINT ["/tmp/entrypoint.sh"]
EXPOSE 3000
The sample application, example.p6w is very simple and is only considered as the way to check that Bailador works correctly:
use Bailador;
get '/' => sub {
"hello world"
}
baile(3000,'0.0.0.0');
Here how the application get run via entry point script, entrypoint.sh :
#!/bin/bash
perl6 /tmp/example.p6w
Run application
Once the image is ready you run a docker container based on this image, as if everything is built correctly you will get running sample application:
docker run -d -p 3000:3000 bailador
Check the application by sending http request:
curl 127.0.0.1:3000
Update Docker image
The promising feature of bailador-Docker-sparrowdo is you can check the latest Bailador source changes by updating existing Docker image, so you don’t have to rebuild the image from the scratch and save your time. This is possible due to main configuration and build logic is embedded into image through the sparrowdo gets installed into it.
This is how you can do this.
First find out existing bailador image and run the container:
docker run -it -p 3000:3000 --entrypoint bash bailador
Notice that we don’t detach the image as we did when just wanted to run the sample application. Moreover we override default enrty point as we need an bash shell to login into container.
Once logged into the container just run sparrowdo scenario again, as we did when build the image via Dockerfile:
sparrowdo --no_sudo --local_mode --sparrowfile=/tmp/sparrowfile
Sparrowdo will pick up the latest changes for Baildor source code from github and apply them.
To ensure that sample application runs on new code, lets run it manually:
perl /tmp/example.p6w
^C # to stop the application
Now we can update the image by using `docker commit` command. Not exiting from the running Docker container, in parallel console lets do that:
$ docker ps # to find out the image id
$ docker commit $image_id bailador # to commit changes made in container into bailador image
$ docker stop -t 1 $container_id # stop current Docker container
Great. Now our image gets updated and contain latest Bailador source code changes. We can run a sample application the same way as we did before:
docker run -d -p 3000:3000 bailador
Conclusion
Docker is an efficient and powerful tool to share applications across teams. Sparrowdo plays nicely with Docker ecosystem providing a comprehensive DSL to describe any complicated scenarios to build Docker images and more impressive to update existing images “on the fly”, saving developers’ time.
Join Bailador project
If you’d like to get involved in the Bailador project, contact me and I’ll send you an invitation to our Slack channel.
