Problem with using self-built GDAL in Docker

I am trying to prepare an Ubuntu 22.04 Docker image with GDAL 3.2.2. This GDAL installation needs to have ECW support, which means I cannot use the pre-built gdal-bin package that can be installed using apt.

I can build and install GDAL with these specs in the Docker container. But when running a simple test command on a simple tiff file I get an error that I have no idea how to debug.

$ gdalinfo --version
GDAL 3.2.2, released 2021/03/05
$ gdalinfo test.tif
Driver: GTiff/GeoTIFF
Files: test.tif
Size is 572, 577
Aborted (core dumped)

The steps I took was starting with a regular Ubuntu 22.04 Docker image. Installing prerequisites (gcc and stuff). Downloading the ECW SDK. Install that. Download the source of gdal 3.2.2. Configure the build to include ECW. Use the make file to build and then install.

If I do not use a self-built GDAL but rather install gdal-bin using apt directly, it works for the tiff file, but it would mean I have no ECW support.

I have also successfully built and used GDAL with ECW directly on Ubuntu 22.04 without Docker.

Does anyone know a solution for this or have any idea in which direction I could look to potentially debug it?

You can try the same process using a dedicated Docker iage like klokantech/gdal

docker run -ti --rm -v $(pwd):/data klokantech/gdal gdalinfo yourfile.tif

> The container is minimal (about 350 MB) and is compiled from latest stable GDAL with MrSID, ECW and JP2KAK drivers.

Since the Dockerfile is quite old, you can rebuild your own image from it, making sure you get the right version of GDAL.

This Dockerfile does install GDAL with ECW support, which is what you need.
However, it has a few potential issues:

1. The Dockerfile uses Debian 7 as the base image, which is quite old. You mentioned you are using Ubuntu 22.04 as your base image, which is much newer.

2. The Dockerfile installs GDAL version 1.11.1, but you want to install GDAL 3.2.2.

3. The Dockerfile requires private URLs to download the ECW and other SDKs. You will need to replace these with the actual URLs where these SDKs can be downloaded.

To use this Dockerfile, you would need to make a few changes:

1. Change the base image from Debian 7 to Ubuntu 22.04 (or possibly an updated version of Debian if you prefer that).

2. Change the GDAL version from 1.11.1 to 3.2.2.

3. Replace the placeholders in the SDKS_URL environment variable with the actual URLs where the ECW and other SDKs can be downloaded.

Once you have made these changes, you should be able to build a Docker image that meets your requirements.

Something like:

FROM ubuntu:22.04
ENV DEBIAN_FRONTEND noninteractive

RUN apt-get -qq update && apt-get -qq -y --no-install-recommends install \
    autoconf \
    automake \
    build-essential \
    curl \
    libcurl4-gnutls-dev \
    libepsilon-dev \
    libexpat1-dev \
    libfreexl-dev \
    libgeos-dev \
    libgif-dev \
    libhdf4-alt-dev \
    libhdf5-serial-dev \
    libjpeg-dev \
    liblcms2-dev \
    liblzma-dev \
    libnetcdf-dev \
    libpcre3-dev \
    libpng-dev \
    libpodofo-dev \
    libpoppler-dev \
    libproj-dev \
    libspatialite-dev \
    libsqlite3-dev \
    libtbb2 \
    libwebp-dev \
    libxerces-c-dev \
    libxml2-dev \
    netcdf-bin \
    poppler-utils \
    python3-dev \
    unixodbc-dev \
    unzip

ENV SDKS_URL http://your.url.here
ENV ECW_VERSION 3.3
ENV ECW_DATE 2006-09-06
ENV ECW_NAME libecwj2-$ECW_VERSION
ENV ECW_DIR /usr/local/src/$ECW_NAME

RUN curl -s $SDKS_URL/$ECW_NAME-$ECW_DATE.zip -o $ECW_DIR.zip \
    && unzip -q $ECW_DIR.zip -d /usr/local/src \
    && cd $ECW_DIR \
    && ./configure --prefix=/usr/local \
    && make \
    && make install

# Remove MRSID and KAKADU if not needed
# ...

ENV GDAL_VERSION 3.2.2
RUN mkdir -p /usr/local/src \
    && curl -s http://download.osgeo.org/gdal/$GDAL_VERSION/gdal-$GDAL_VERSION.tar.gz \
    | tar xz -C /usr/local/src

WORKDIR /usr/local/src/gdal-$GDAL_VERSION

RUN ./configure \
    --prefix=/usr/local \
    --without-libtool \
    --with-ecw=/usr/local \
    --with-epsilon \
    --with-libkml \
    --with-liblzma \
    --with-podofo \
    --with-poppler \
    --with-python \
    --with-spatialite \
    --with-threads \
    --with-webp \
    && make \
    && make install \
    && ldconfig

You will need to replace http://your.url.here with the actual URL where you are hosting the ECW SDK. And adjust its version (see GDAL wiki ECW)

Also, note that I have removed the installation steps for MRSID and KAKADU as I assumed you do not need those. If you do, you will need to put them back in and adjust the URLs and versions as necessary.

Dirk Eddelbuettel adds in the comments:

> Alternatively, if you are familiar with building a .deb you can modify the existing binary package gdal-bin (and libgdal-dev etc) which I had done in the past to add TiileDB support. The Launchpad site by Canonical can build and host the binaries for various releases; I use this regularly for "local" version of updated Debian packages (and just did so on the weekend for mlpack).
The .deb files then go rather easily into your (much quicker !!) Docker build step.

Here, instead of building GDAL directly from source, this approach involves modifying the existing Debian packages (gdal-bin, libgdal-dev, etc.) to include ECW support, and then building .deb packages from those modified sources. You can then install these .deb packages in your Docker container.

This approach has a couple of advantages:

1. Faster Docker builds: Building GDAL from source can take a long time. If you have pre-built .deb packages, you can install them with apt in your Dockerfile, which is much faster.

2. Easier maintenance: Once you have the .deb packages, you can use them in multiple Dockerfiles without having to repeat the complex GDAL build process.

The basic steps to follow are:

1. Modify the GDAL source code to include ECW support. This is similar to what you were doing before, but instead of building GDAL directly, you will build a .deb package.

2. Build the .deb packages. This can be done using a tool like dpkg-buildpackage.

3. Upload the .deb packages to a repository. You can use a personal package archive (PPA) on Launchpad for this.

4. In your Dockerfile, add the PPA to your list of repositories and install the GDAL packages with apt.

Your Dockerfile would include something like:

FROM ubuntu:22.04
ENV DEBIAN_FRONTEND noninteractive

RUN apt-get -qq update && apt-get -qq -y --no-install-recommends install \
    software-properties-common \
    apt-transport-https \
    curl

# Add your PPA to the list of repositories
RUN add-apt-repository ppa:your/launchpad/ppa

# Update the package list and install the modified GDAL packages
RUN apt-get update && apt-get install -y \
    gdal-bin \
    libgdal-dev \
    # other GDAL packages as needed

Replace ppa:your/launchpad/ppa with the actual PPA where you are hosting the .deb packages.

Keep in mind that this is a high-level overview. Modifying Debian packages, building .deb packages, and using Launchpad are all complex tasks that require a good understanding of the Debian packaging system. If you're not already familiar with these processes, you may want to stick with the first approach.