Java Edition Face Detection Detailed Explanation Part I: Docker image of the operating environment (CentOS+JDK+OpenCV)

Welcome to my GitHub

https://github.com/zq2599/blog_demos

Content: Classification and summary of all original articles and supporting source code, involving Java, Docker, Kubernetes, DevOPS, etc.;

Overview of this article

• If you have read "Three-Minute Speed Experience: Face Detection in Java Edition" , and even hands-on actual operation, you should be interested in the technical details behind it, and then please follow Xinchen to start the actual battle. Develop this application until there is;
• First determine our goals:
• Developed java version of face detection application
• Make this application into a docker image
• Run this application in 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 and integrate it into the basic image to get the final java application image
• The goal of this article is the first step above: <font color="blue">prepare the docker base image</font>

About the basic mirroring of face detection applications

• If you have the experience of making Java application mirrors, you will definitely have questions: As shown in the red box in the figure below, don’t you generally use the official mirror of OpenJDK as the basic mirror? Why take an article to talk about basic mirroring?

• For the application of face detection, the official image of OpenJDK is not enough, because the realization of face detection with java requires a key technology: <font color="red"> javacv </font>, running in javacv Some local libraries of opencv need to be used in, so opencv needs to be installed in the operating environment
• As shown in the figure below, a face detection application consists of the following six parts from bottom to top. It is much more convenient if the bottom operating system, JDK, and OpenCV are made into basic images. When we develop applications, we only need to pay attention to the top three layers. That's it, isn't the upper three layers just an ordinary maven project?

• At this point, you should be very clear about what to do next: Write a Dockerfile file to make an image, and this image must contain <font color="blue">CentOS + JDK1.8 + OpenCV</font>

Walk in two steps

• I plan to make a CentOS + JDK mirror first, and then make a mirror that integrates OpenCV on this basis, so that in some scenarios where OpenCV is not needed, I can use CentOS + JDK1.8 mirror alone
• The analysis is complete, let's get started

Mirror of CentOS + JDK

• The reason why CentOS is chosen as the operating system is that it is the most commonly used in daily work
• Looking at the various official images of OpenJDK, I did not find CentOS as the operating system, so do it 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 then install them according to different operating systems. The logic is simple and clear, so I won't say much:

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 a mirror image. If you have an account with hub.docker.com, you can also Push it to the central warehouse for more people to use
• Use the history command to look at the contents of the mirror. The details are as follows. The total is more than 500 megabytes, which is not small:

CN0014009475M:~ will$ 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 execute the following command to download it locally:

docker pull bolingcavalry/centos7.6-jdk8:0.0.3

CentOS+JDK+OpenCV mirror

• Next, you can integrate OpenCV. The content of the Dockerfile is shown below. The basic image is just made <font color="blue">bolingcavalry/centos7.6-jdk8:0.0.1</font>, first install a lot of compilation The required application, then download the source code of OpenCV-3.4.3 version, and then compile it, it's as simple as that (but there is still a lot of debugging work in the meantime, not to mention, it is tears if you say more):

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 \
        cmake \
        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 opencv-3.4.3.zip https://codeload.github.com/opencv/opencv/zip/3.4.3; \
    unzip opencv-3.4.3.zip; \
    rm -rf opencv-3.4.3.zip; \
    cd opencv-3.4.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

• After writing, execute <font color="blue">docker build -t bolingcavalry/opencv3.4.3:0.0.3 .</font> to generate a mirror. If you have an account with hub.docker.com, you can also add it Push to the central warehouse for more people to use
• Use the history command to look at the contents of the mirror. The details are as follows. Take a breath. With such a large volume, will dear readers kill me...:

CN0014009475M:~ will$ docker history bolingcavalry/opencv3.4.3:0.0.3
IMAGE          CREATED       CREATED BY                                      SIZE      COMMENT
f0306d7a2594   2 days ago    /bin/sh -c set -eux;     curl -fL -o opencv-…   2.99GB    
<missing>      2 days ago    /bin/sh -c set -eux;     yum install -y     …   638MB     
<missing>      2 days ago    /bin/sh -c echo "export LC_ALL=en_US.UTF-8" …   1.84kB    
<missing>      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 execute the following command to download it locally:

docker pull bolingcavalry/opencv3.4.3:0.0.3

• I want to remind you that the compilation of opencv is very time-consuming, please make sure 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">bolingcavalry/opencv3.4.3:0.0.3</font> that meets our requirements has been completed. With it, we have all the jdk and opencv needed for our Java applications. Now, let’s develop this face detection application in the next article;

You are not alone, Xinchen and original are 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 pay attention to the public account: programmer Xin Chen

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