Advantages of containerisation using buildpacks

The solution

The solution to improve and ensure continuity in the long run of the solution was the use of containerisation with buildpacks. This solution allowed the developers to perform at the application level upgrades, creating docker images without docker files and running containerised code with almost zero configuration.

The use of dockers has many advantages, allowing the rapid scaling of projects and controlling infrastructure costs. The advantages come at the expense of the dependencies necessary at the source code level, leading to challenges at the build and runtime level, wherein specific scenarios the docker files had to go to all the source code. The use of docker files at source code leads to a complexity of assessing all the dependencies to run at the production level. e.g. of a simple docker in node that had to go to all the source code:

-- docker file
FROM Ubuntu 19.04
COPY ./app
RUN make install_node
RUN make install_yarn
CMD yarn

The advantages of containers comprise the source code that can be inserted into a buildpack, as a way to manage containers with scalability, adding source code to output a docker image. This approach is divided into four phases:

1. Detect script

Through a detect script, a piece of runnable source code (e.g. json) can be inserted, if the code language matches the buildpack, lead to a build step.

2. Build step

Installs node modules dependencies such as typescripts and others, then run and compile steps.

3. Export step

Takes all the artefacts that have been created and export them into a runtime image.

4. Caching

Manages all the reusable artefacts from the build and makes them available after the build, leading to efficiencies.

This process can be done locally through the installation of a docker (view docs.docker.com), installing the pack command-line tool (view buildpacks.io), and adding some source code available (e.g. for a node project will need to have a package.json file).

Buildpacks have advantages in the management of dependencies when the project is scaling, one important to highlight is that an update can be done locally and push the updated layer to the registry in the cloud, ensuring coherence and save time. Another positive point about layers, although one can say the first image can be slower to build, in subsequent builds, it will be applied the artefacts cache and speeds up the entire process. This layer update can be done through toml file caching node modules, yarn and node.