Docker on Martin Ahrer

Building Docker Images with bake

Tue, 03 Dec 2024 00:00:00 +0000

Platform engineers and build pipeline engineers constantly are faced with the challenge of building container images for providing images to be used as application base or for running pipeline tasks. Probably such images have to be provided as multiple variants for multiple versions of software packages to be included.

Docker Multiplatform Build

Thu, 12 Sep 2024 00:00:00 +0000

The Arm CPU architecture is getting more and more popular even on desktop developer devices.

A comparative analysis of Arm, AMD, and Intel costs in the Amazon cloud has shown that Graviton2 processors can be significantly more cost-efficient than other platforms. The study compared the 16xlarge instances based on the m6g (Graviton2, Arm), m5a (EPYC1, AMD), and m5n (Xeon Cascade Lake, Intel) for the 64-vCPU count. Not only are the Arm-based instances cheaper than AMD and Intel, they can achieve 40% better performance per dollar when translating the time to completion of SPEC tests to hours and multiplying the result by hourly cost.

— https://bell-sw.com/blog/application-cost-reduction-with-arm-servers

Google Container Tools - Jib

Sun, 19 Apr 2020 00:00:00 +0000

With this post we close the series of articles taking a deep dive on building Docker images. We look at a building Docker images for running Java applications in a Docker container with Jib which is part of the Google Container Tools.

Jib

Jib is highly opinionated about building Java Docker containers using Maven or Gradle as build tool. So it offers plugin support for the above mentioned build tools.

Docker BuildKit

Thu, 16 Apr 2020 00:00:00 +0000

In the previous blog post of the building docker images series we had a look at Docker image build pipelines. We revealed typical problems and looked at how to overcome some by utilizing multistage builds.

In part 4 of this series we work with an addition to the Docker tooling which is BuildKit.

Docker image build pipeline

Fri, 30 Aug 2019 00:00:00 +0000

Let’s recap what we have covered in this blog post series so far. In Building a Docker Image we had a look at the anatomy of a Docker image. And Optimizing a Docker Image shed some light on optimizations when building an image.

Optimizing a Docker Image

Tue, 20 Aug 2019 00:00:00 +0000

This post continues where we left off with Building a Docker Image. We are looking into how we can optimize the process of building a Docker image. This optimization can aim at reducing the size of images built or the time it takes for packaging an image.

Building a Docker Image

Sat, 17 Aug 2019 00:00:00 +0000

This post starts a series of articles taking a deep dive on building Docker images. But before we look at building a Docker image let’s briefly recap the essentials we need to know about container images.

A Docker image is built up from a series of layers where each layer represents an instruction in the image’s Dockerfile. When Docker materializes an image and creates a container from this image, a storage driver handles the details about the way these layers interact with each other. Different storage drivers are available, which have advantages and disadvantages in different situations (e.g. AUFS, overlay, overlay2, btrfs,zfs). All drivers have in common that they use stackable image layers and the copy-on-write (CoW) strategy for writing files.

Continuous delivery infrastructure as code

Wed, 10 May 2017 00:00:00 +0000

This is part 1 of a series of posts covering Docker in a Continuous Delivery environment.

Today I’m showing how simple it is to setup a continuous delivery build pipeline infrastructure using Docker. In an upcoming post we will look at Jenkins pipeline as code creating Docker images and running integration tests against Docker containers. The series will close with an article explaining how we can move all containers built throughout this series of posts in a Docker swarm environment.

docker-compose scripting

Tue, 07 Feb 2017 00:00:00 +0000

This time we look at managing large numbers of compose projects.

When building complex infrastructure using docker-compose we soon end in a mess of scripts for starting, updating, etc. containers. I will try to describe an approach that has helped to get this done in a very structured way.

docker-compose modularization

Mon, 06 Feb 2017 00:00:00 +0000

In this blog post we are looking into how we can create modular compose projects.

With docker-compose we can describe a bunch of containers and container related resources such as networks and volumes that make up an application. All this is usually going into a docker-compose.yml file.