CI/CD as Code Part IV - Stateless Jenkins : Jobs as Code - Advanced

-
Image
In the previous article of these examples , we created a stateless jenkins container which can be initialised solely by using scripts. In that example, a seed job for jobdsl plugin was also implemented. This job was later on used to create an automated simple jenkins job inline. In order to create more complex jobs in an automated fashion, we will extend previous seed job implementation further in this example. Our extended seedJob will poll a job definition repository to gather the information on how to create new complex jobs for some other remote repositories.
Post a Comment

Creating a Customised Mysql Docker Image Supported by Initialisation Scripts

-

Summary

This blog post aims to provide an introduction to create a database container  with predefined data in it. Therefore, it does not address explanations of basic docker commands and instructions. 

Containerisation has many advantages.  One advantage among these is getting up and running quickly with a production ready datasource, which has predefined data in it. This way we can share and use the application data state in local development environments easily.
In this article we are going to create such a customised datasource container, in order to speed up our development activities. Even though, mysql is used as the database system in this blog post, similar concepts are applicable to other database systems as well.

The steps that we're going to follow to reach our goal are as follows:
  1. Creating a Dockerfile for our base container
  2. Implementing the scripts for database/table creation and sample data insertion. 
  3. Building our customised mysql docker image and verifying the container state

1. Creating the Dockerfile for a customised Mysql Docker Image

Initially,  create the directory structure to store configuration files for your mysql docker container.
$mkdir mysql-docker
$cd mysql-docker
$mkdir init-scripts

Now we can start writing our custom mysql docker image file.  Create a Dockerfile under the root folder "mysql-docker". We are going to use official Mysql Docker Image as our base image. Add the following content to the file that you've created:

FROM mysql:5.7

LABEL description="My Custom Mysql Docker Image"

# Add a database
ENV MYSQL_DATABASE CARDS

#Check out docker entry point for further configuration : 
# https://github.com/docker-library/mysql
COPY ./init-scripts/ /docker-entrypoint-initdb.d/

As mentioned earlier, we have used official mysql docker image for mysql version 5.7 as our parent image. We also added some metadata information for our image.
On the line starting with ENV MYSQL_DATABASE CONTACTS, we informed the base mysql container that we are going to create and use "CONTACTS" database in this customised docker image. MYSQL_DATABASE is an environment variable provided by the parent image. This step is not a mandatory step, we could have also used our initialisation scripts to achieve the same goal, yet for demonstration purposes it's easier to implement it like this.
 The COPY ./scripts/ /docker-entrypoint-initdb.d/ instruction on the last line of our docker file  will be used to copy the initialisation scripts, which we are going to create in the next step, to the filesystem of the container.
The important point here is the destination folder "/docker-entrypointpinitdb.d/".  Mysql base image defines this folder as the startup scripts folder and executes every sql file under this folder while the container is starting up. It's not clearly documented in the official container documentation page (at least at the time of writing); however, you can see that this is the case by checking out docker entry point script implementation in the official mysql docker image repository.

We're done with creating our image file description.  We can now add our initialisation scripts.

2. Implementing the scripts for table creation and sample data insertion

Add the following sql scripts under the folder "init-scripts", which we created before:

-- create_tables.sql
CREATE TABLE card (
  id bigint(20) NOT NULL,
  back varchar(255) NOT NULL,
  front varchar(255) NOT NULL,
  hint varchar(255) DEFAULT NULL,
   PRIMARY KEY (id)
  );


-- insert_data.sql
INSERT INTO card (id, front, back, hint) values (1, 'Front 1', 'Back 1', 'Hint 1');
INSERT INTO card (id, front, back, hint) values (2, 'Front 2', 'Back 2', 'Hint 2');
INSERT INTO card (id, front, back, hint) values (3, 'Front 3', 'Back 3', 'Hint 3');
INSERT INTO card (id, front, back, hint) values (4, 'Front 4', 'Back 4', 'Hint 4');
INSERT INTO card (id, front, back, hint) values (5, 'Front 5', 'Back 5', 'Hint 5');

3. Building and running the container

The Dockerfile, and database initialisation scripts are ready for our image. It's now time to build and run our container. 

In order to build the image run the following command: 

$ docker build -t mysql-docker .
Sending build context to Docker daemon   7.68kB
Step 1/4 : FROM mysql:8.0
 ---> 98455b9624a9
Step 2/4 : LABEL description="My Custom Mysql Docker Image"
 ---> Using cache
 ---> 6bb1abb1370e
Step 3/4 : ENV MYSQL_DATABASE CARDS
 ---> Using cache
 ---> fda7d70507cb
Step 4/4 : COPY ./init-scripts/ /docker-entrypoint-initdb.d/
 ---> Using cache
 ---> a5b2181dd613
Successfully built a5b2181dd613
Successfully tagged mysql-docker:latest

If the image is built successfully, you can run your container with the following command:
 
$ docker run -d -p 63306:3306 --name mysql-docker \
-e MYSQL_ROOT_PASSWORD=secret mysql-docker

The last step is to verify whether the container got up and running in the expected state. In order to do this we can use  docker exec command, which is used for running a command in an already running container.  Run the exec command as follows to open a bash session in the container:
$ docker exec -it mysql-docker bash
root@ed27a9ae3b98:/#

Since we are inside our container right now, we can execute database commands and verify that our initial state is as expected:

root@ed27a9ae3b98:/# mysql -u root -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 3
Server version: 5.7.25 MySQL Community Server (GPL)

Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> use CARDS
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> show tables;
+-----------------+
| Tables_in_CARDS |
+-----------------+
| card            |
+-----------------+
1 row in set (0.00 sec)

mysql> select * from card;
+----+--------+---------+--------+
| id | back   | front   | hint   |
+----+--------+---------+--------+
|  1 | Back 1 | Front 1 | Hint 1 |
|  2 | Back 2 | Front 2 | Hint 2 |
|  3 | Back 3 | Front 3 | Hint 3 |
|  4 | Back 4 | Front 4 | Hint 4 |
|  5 | Back 5 | Front 5 | Hint 5 |
+----+--------+---------+--------+
5 rows in set (0.00 sec)

As you can see, we have our initial database state in our container now. As a next step we can push this imge to our docker hub to share it within our development team. This way every member of our team can run this image locally and play around with the data without affecting other developers.



Comments

Post a Comment

Popular posts from this blog

CI/CD as Code Part IV - Stateless Jenkins : Jobs as Code - Advanced

-
Image
In the previous article of these examples , we created a stateless jenkins container which can be initialised solely by using scripts. In that example, a seed job for jobdsl plugin was also implemented. This job was later on used to create an automated simple jenkins job inline. In order to create more complex jobs in an automated fashion, we will extend previous seed job implementation further in this example. Our extended seedJob will poll a job definition repository to gather the information on how to create new complex jobs for some other remote repositories.
Read more

Generating Rest API Documentation Using Rest Assured Tests in a Spring Boot Based Application

-
A clear and concise REST API documentation is mandatory for a rest api to be easily used. However, it's error prone and is also hard to maintain an api documentation if we attempt to write it manually. This sample project demonstrates how we can use rest assured tests to generate api documentation with a small amount of manual work. Project Setup This sample uses Spring Boot 2.x as its core framework. In order to achieve our goal it's also necessary to add some additional dependencies and configure some maven plugins.  These configuration needs and dependencies are explained step by step in the following subsections. You can also checkout initial setup for the demonstration using the link below: git clone --branch rest-assured-asciidoc_start git@github.com:entrofi/spring.git The final form of the demonstration can also be checked-out using: git clone --branch rest-assured-asciidoc_finish git@github.com:entrofi/spring.gi t Dependencies The dependencies neede...
Read more

Testing Java Projects with Groovy

-
This example demonstrates how we can implement our tests using groovy in a java based project. You might be asking why. Well, implementing tests with groovy has some advantages. However, this article does not try to convince you groovy is a better way to implement your tests. It's just another alternative to implement your tests. If you want to investigate testing java projects with groovy, the article will, then, provide you a starting point for your investigation.
Read more