Create the basic Docker image (CentOS7+JDK8+OpenCV4) that the JavaCV application depends on

Welcome to my GitHub

https://github.com/zq2599/blog_demos

Content: All original articles are categorized and summarized and supporting source code, involving Java, Docker, Kubernetes, DevOPS, etc.;

Overview of this article

• In the "Three Minutes: Extremely Fast Experience JAVA Target Detection (YOLO4)" , we experienced the powerful object recognition ability of YOLO4, as shown below:

• If you have read "Three Minutes: Extremely Fast Experience JAVA Version of Object Detection (YOLO4)" , and have even done the actual operation, you should be interested in the technical details behind it. Next, please follow Xinchen to fight. Develop this application from scratch;

actual combat content

• In order to reduce the impact of environment and software differences, make the running and debugging of the program easier, and in order to allow the application to run in the container environment, the entire application will eventually be made into a docker image, so our goals are set to the following three items:
• Develop a java version of object recognition application
• Make this application into a docker image
• Run the application in the docker environment
• Based on the above goals, we can determine the following steps:
• Prepare the docker base image
• develop java applications
• Package the java application into a package file, integrate it into the base image, and get the final java application image
• The whole process is shown in the figure below:

• The goal of this article is the first step above: prepare the docker base image

Make a base image

• If you have experience in making java application mirrors, you will definitely have questions: As shown in the red box in the figure below, isn't the official image of OpenJDK used as the base mirror? Why use an article to talk about basic mirroring?

• For the application of object detection, the official image of OpenJDK is not enough, because the implementation of detection in java requires a key technology: javacv, some native libraries of opencv need to be used during the running process of javacv, so it needs to be installed in the running environment opencv
• As shown in the figure below, an application consists of six parts from bottom to top. It is much more convenient if the operating system, JDK, and OpenCV at the bottom are made into basic images. When we develop applications, we only need to pay attention to the above three layers, and Isn't the top three layers an ordinary maven project?

• At this point, you should be very smart about what to do next: write a Dockerfile file to make an image, and this image must have CentOS7 + JDK1.8 + OpenCV4

walk in two steps

• I plan to make an image of CentOS7 + JDK8 first, and then make another image that integrates OpenCV, so that in some scenarios where OpenCV is not needed, I can still use the image of CentOS7 + JDK1.8 alone
• The analysis is complete, let's get started

Mirror for CentOS7 + JDK8

• The reason why I choose CentOS as the operating system is because it is the most commonly used in my daily work.
• Looking at the various official images of OpenJDK, we have not found CentOS as an operating system, so make one yourself. The idea is very simple: find the Dockerfile of OpenJDK, and replace its basic image with CentOS7.6.
• The following are all the contents of the Dockerfile. It can be seen that the core is to download files and install them according to different operating systems. The logic is simple and clear, so I won't say more:

FROM centos:7.6.1810

RUN set -eux; \
    yum install -y \
        gzip \
        tar \
        binutils \
        freetype fontconfig \
    ;

ENV JAVA_HOME /usr/java/openjdk-8
ENV PATH $JAVA_HOME/bin:$PATH

# Default to UTF-8 file.encoding
ENV LANG C.UTF-8

RUN set -eux; \
    \
    arch="$(objdump="$(command -v objdump)" && objdump --file-headers "$objdump" | awk -F '[:,]+[[:space:]]+' '$1 == "architecture" { print $2 }')"; \
    case "$arch" in \
        'i386:x86-64') \
            downloadUrl='https://github.com/AdoptOpenJDK/openjdk8-upstream-binaries/releases/download/jdk8u292-b10/OpenJDK8U-jdk_x64_linux_8u292b10.tar.gz'; \
            ;; \
        'aarch64') \
            downloadUrl='https://github.com/AdoptOpenJDK/openjdk8-upstream-binaries/releases/download/jdk8u292-b10/OpenJDK8U-jdk_aarch64_linux_8u292b10.tar.gz'; \
            ;; \
        *) echo >&2 "error: unsupported architecture: '$arch'"; exit 1 ;; \
    esac; \
    \
    curl -fL -o openjdk.tgz "$downloadUrl"; \
    curl -fL -o openjdk.tgz.asc "$downloadUrl.sign"; \
    \
    export GNUPGHOME="$(mktemp -d)"; \
# pre-fetch Andrew Haley's (the OpenJDK 8 and 11 Updates OpenJDK project lead) key so we can verify that the OpenJDK key was signed by it
# (https://github.com/docker-library/openjdk/pull/322#discussion_r286839190)
# we pre-fetch this so that the signature it makes on the OpenJDK key can survive "import-clean" in gpg
    gpg --batch --keyserver keyserver.ubuntu.com --recv-keys EAC843EBD3EFDB98CC772FADA5CD6035332FA671; \
# TODO find a good link for users to verify this key is right (https://mail.openjdk.java.net/pipermail/jdk-updates-dev/2019-April/000951.html is one of the only mentions of it I can find); perhaps a note added to https://adoptopenjdk.net/upstream.html would make sense?
# no-self-sigs-only: https://salsa.debian.org/debian/gnupg2/commit/c93ca04a53569916308b369c8b218dad5ae8fe07
    gpg --batch --keyserver keyserver.ubuntu.com --keyserver-options no-self-sigs-only --recv-keys CA5F11C6CE22644D42C6AC4492EF8D39DC13168F; \
    gpg --batch --list-sigs --keyid-format 0xLONG CA5F11C6CE22644D42C6AC4492EF8D39DC13168F \
        | tee /dev/stderr \
        | grep '0xA5CD6035332FA671' \
        | grep 'Andrew Haley'; \
    gpg --batch --verify openjdk.tgz.asc openjdk.tgz; \
    rm -rf "$GNUPGHOME"; \
    \
    mkdir -p "$JAVA_HOME"; \
    tar --extract \
        --file openjdk.tgz \
        --directory "$JAVA_HOME" \
        --strip-components 1 \
        --no-same-owner \
    ; \
    rm openjdk.tgz*; \
    \
    rm -rf "$JAVA_HOME/jre/lib/security/cacerts"; \
# see "update-ca-trust" script which creates/maintains this cacerts bundle
    ln -sT /etc/pki/ca-trust/extracted/java/cacerts "$JAVA_HOME/jre/lib/security/cacerts"; \
    \
# https://github.com/oracle/docker-images/blob/a56e0d1ed968ff669d2e2ba8a1483d0f3acc80c0/OracleJava/java-8/Dockerfile#L17-L19
    ln -sfT "$JAVA_HOME" /usr/java/default; \
    ln -sfT "$JAVA_HOME" /usr/java/latest; \
    for bin in "$JAVA_HOME/bin/"*; do \
        base="$(basename "$bin")"; \
        [ ! -e "/usr/bin/$base" ]; \
        alternatives --install "/usr/bin/$base" "$base" "$bin" 20000; \
    done; \
    \
# basic smoke test
    javac -version; \
    java -version

• After writing, execute <font color="blue">docker build -t bolingcavalry/centos7.6-jdk8:0.0.1 .</font> to generate the image. If you have an account on hub.docker.com, you can also Push it to the central repository for more people to use
• Use the history command to see the contents of the mirror image. The details are as follows. The total is more than 500 megabytes, which is not too small:

will@Mac-mini$ docker history bolingcavalry/centos7.6-jdk8:0.0.1
IMAGE          CREATED       CREATED BY                                      SIZE      COMMENT
a5dead4a6505   2 days ago    /bin/sh -c set -eux;         arch="$(objdump…   209MB     
<missing>      2 days ago    /bin/sh -c #(nop)  ENV LANG=C.UTF-8             0B        
<missing>      2 days ago    /bin/sh -c #(nop)  ENV PATH=/usr/java/openjd…   0B        
<missing>      2 days ago    /bin/sh -c #(nop)  ENV JAVA_HOME=/usr/java/o…   0B        
<missing>      2 days ago    /bin/sh -c set -eux;     yum install -y     …   144MB     
<missing>      2 years ago   /bin/sh -c #(nop)  CMD ["/bin/bash"]            0B        
<missing>      2 years ago   /bin/sh -c #(nop)  LABEL org.label-schema.sc…   0B        
<missing>      2 years ago   /bin/sh -c #(nop) ADD file:54b004357379717df…   202MB

• I have pushed it to hub.docker.com here, and I can download it locally by executing the following command:

docker pull bolingcavalry/centos7.6-jdk8:0.0.3

CentOS7+JDK8+OpenCV4 image

• Next, you can integrate OpenCV4. There are two key points to note here:

1. Constrained by JavaCV dependencies, the version of OpenCV should use <font color="red"> 4.5.3 </font>
2. When OpenCV is compiled, the cmake version is required to be 3.x, so you need to download the corresponding version of cmake

• Finally, the contents of the Dockerfile are as follows. The basic image is the previously prepared <font color="blue">bolingcavalry/centos7.6-jdk8:0.0.1</font>. First, install a lot of applications required for compilation, and then download cmake and install it, then download the source code of the OpenCV-4.5.3 version and compile it, it's that simple (but there is still a lot of debugging work in between, let's not talk about it, it will be tears if you talk too much):

FROM bolingcavalry/centos7.6-jdk8:0.0.1

RUN echo "export LC_ALL=en_US.UTF-8"  >>  /etc/profile \
    && source /etc/profile

RUN set -eux; \
    yum install -y \
        make \
        gcc \
        gcc-c++ \
        gtk+-devel \
        gimp-devel \
        gimp-devel-tools \
        gimp-help-browser \
        zlib-devel \
        libtiff-devel \
        libjpeg-devel \
        libpng-devel \
        gstreamer-devel \
        libavc1394-devel \
        libraw1394-devel \
        libdc1394-devel \
        jasper-devel \
        jasper-utils \
        swig \
        python \
        libtool \
        nasm \
        build-essential \
        ant \
        unzip \
    ;

RUN set -eux; \
    curl -fL -o cmake-3.12.2-Linux-x86_64.tar.gz https://cmake.org/files/v3.12/cmake-3.12.2-Linux-x86_64.tar.gz \
    && tar -zxvf cmake-3.12.2-Linux-x86_64.tar.gz \
    && mv cmake-3.12.2-Linux-x86_64 cmake-3.12.2 \
    && ln -sf /cmake-3.12.2/bin/* /usr/bin; \
    curl -fL -o opencv-4.5.3.zip https://codeload.github.com/opencv/opencv/zip/4.5.3; \
    unzip opencv-4.5.3.zip; \
    rm -rf opencv-4.5.3.zip; \
    cd opencv-4.5.3; \
    mkdir build; \
    cd build; \
    cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local ..; \
    make; \
    make install; \
    cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -DBUILD_TESTS=OFF ..;\
    make -j8; \
    make install

• Execute the command <font color="blue">docker build -t bolingcavalry/opencv4.5.3:0.0.1 .</font> to generate the image. If you have an account on hub.docker.com, you can also push it to Central warehouse for more people to use
• Use the history command to see the content of the mirror image. The details are as follows. Take a breath. With such a large volume, will my dear readers kill me...:

will@Mac-mini centos7-jdk8 % docker history bolingcavalry/opencv4.5.3:0.0.1
IMAGE          CREATED        CREATED BY                                      SIZE      COMMENT
d1518ffa4699   5 days ago     RUN /bin/sh -c set -eux;     curl -fL -o cma…   819MB     buildkit.dockerfile.v0
<missing>      5 days ago     RUN /bin/sh -c set -eux;     yum install -y …   637MB     buildkit.dockerfile.v0
<missing>      5 days ago     RUN /bin/sh -c echo "export LC_ALL=en_US.UTF…   1.84kB    buildkit.dockerfile.v0
<missing>      3 months ago   /bin/sh -c set -eux;         arch="$(objdump…   209MB     
<missing>      3 months ago   /bin/sh -c #(nop)  ENV LANG=C.UTF-8             0B        
<missing>      3 months ago   /bin/sh -c #(nop)  ENV PATH=/usr/java/openjd…   0B        
<missing>      3 months ago   /bin/sh -c #(nop)  ENV JAVA_HOME=/usr/java/o…   0B        
<missing>      3 months ago   /bin/sh -c set -eux;     yum install -y     …   144MB     
<missing>      2 years ago    /bin/sh -c #(nop)  CMD ["/bin/bash"]            0B        
<missing>      2 years ago    /bin/sh -c #(nop)  LABEL org.label-schema.sc…   0B        
<missing>      2 years ago    /bin/sh -c #(nop) ADD file:54b004357379717df…   202MB

• I have pushed it to hub.docker.com here, and I can download it locally by executing the following command:

docker pull bolingcavalry/opencv4.5.3:0.0.1

• Here I want to remind that the compilation of opencv is very time-consuming, please ensure that the performance of the docker host is not too bad, and please wait patiently for the compilation process
• So far, the basic image <font color="blue">opencv4.5.3:0.0.1</font> that meets our requirements has been produced. With it, the jdk and opencv required for our Java application are ready. When developing javacv-related applications, using it as the base image eliminates the need to worry about the environment and dependent libraries, and can finally focus on java development

You are not alone, Xinchen Original is with you all the way

1. Java series
2. Spring Series
3. Docker series
4. kubernetes series
5. database + middleware series
6. DevOps Series

Welcome to the public number: Programmer Xin Chen

Search "Programmer Xinchen" on WeChat, I am Xinchen, I look forward to traveling the Java world with you...
https://github.com/zq2599/blog_demos