Impossible de créer openjdk: image 8-jdk directement

Question

Je suis lentement en train de faire mon chemin à travers le Riot Prendre le contrôle de votre tutoriel Docker Image http://engineering.riotgames.com/news/taking-control-your-docker-image. Ce tutoriel est un peu ancien, il y a donc des changements précis à l'apparence du fichier de fin. Après avoir heurté plusieurs murs, j'ai décidé de travailler dans l'ordre inverse du tutoriel. J'ai réussi à plier l'image jenkinsci officielle dans mon Dockerfile personnel, en commençant par FROM: openjdk: 8-dk. Mais lorsque je tente de se replier dans le OpenJDK: fichier 8-dk dans mon image personnelle, je reçois l'erreur suivante

E: Version '8u102-b14.1-1~bpo8+1' for 'openjdk-8-jdk' was not found ERROR: Service 'jenkinsmaster' failed to build: The command '/bin/sh -c set -x && apt-get update && apt-get install -y openjdk-8-jdk="$JAVA_DEBIAN_VERSION" ca-certificates-java="$CA_CERTIFICATES_JAVA_VERSION" && rm -rf /var/lib/apt/lists/* && [ "$JAVA_HOME" = "$(docker-java-home)" ]' returned a non-zero code: 100 Cosettes-MacBook-Pro:docker-test Cosette$

Je reçois cette erreur même quand je renonçai et directement copié et collé OpenJDK: 8 -jdk Dockerfile dans le mien. Mon but final est d'amener mon Dockerfile personnel au point que ça commence par debian-jessie. Toute aide serait appréciée.

Mon Dockerfile:

FROM buildpack-deps:jessie-scm 

# A few problems with compiling Java from source: 
# 1. Oracle. Licensing prevents us from redistributing the official JDK. 
# 2. Compiling OpenJDK also requires the JDK to be installed, and it gets 
#  really hairy. 

RUN apt-get update && apt-get install -y --no-install-recommends \ 
     bzip2 \ 
     unzip \ 
     xz-utils \ 
    && rm -rf /var/lib/apt/lists/* 

RUN echo 'deb http://deb.debian.org/debian jessie-backports main' > /etc/apt/sources.list.d/jessie-backports.list 

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

# add a simple script that can auto-detect the appropriate JAVA_HOME value 
# based on whether the JDK or only the JRE is installed 
RUN { \ 
     echo '#!/bin/sh'; \ 
     echo 'set -e'; \ 
     echo; \ 
     echo 'dirname "$(dirname "$(readlink -f "$(which javac || which java)")")"'; \ 
    } > /usr/local/bin/docker-java-home \ 
    && chmod +x /usr/local/bin/docker-java-home 

ENV JAVA_HOME /usr/lib/jvm/java-8-openjdk-amd64 

ENV JAVA_VERSION 8u102 
ENV JAVA_DEBIAN_VERSION 8u102-b14.1-1~bpo8+1 

# see https://bugs.debian.org/775775 
# and https://github.com/docker-library/java/issues/19#issuecomment-70546872 
ENV CA_CERTIFICATES_JAVA_VERSION 20140324 

RUN set -x \ 
    && apt-get update \ 
    && apt-get install -y \ 
     openjdk-8-jdk="$JAVA_DEBIAN_VERSION" \ 
     ca-certificates-java="$CA_CERTIFICATES_JAVA_VERSION" \ 
    && rm -rf /var/lib/apt/lists/* \ 
    && [ "$JAVA_HOME" = "$(docker-java-home)" ] 

# see CA_CERTIFICATES_JAVA_VERSION notes above 
RUN /var/lib/dpkg/info/ca-certificates-java.postinst configure 

# Jenkins Specifics 

# install Tini 
ENV TINI_VERSION 0.9.0 
ENV TINI_SHA fa23d1e20732501c3bb8eeeca423c89ac80ed452 

# Use tini as subreaper in Docker container to adopt zombie processes 
RUN curl -fsSL https://github.com/krallin/tini/releases/download/v${TINI_VERSION}/tini-static -o /bin/tini && chmod +x /bin/tini \ 
    && echo "$TINI_SHA /bin/tini" | sha1sum -c - 

# Set Jenkins Environmental Variables 
ENV JENKINS_HOME /var/jenkins_home 
ENV JENKINS_SLAVE_AGENT_PORT 50000 
    # jenkins version being bundled in this docker image 
ARG JENKINS_VERSION 
ENV JENKINS_VERSION ${JENKINS_VERSION:-2.19.1} 
    # jenkins.war checksum, download will be validated using it 
ARG JENKINS_SHA=dc28b91e553c1cd42cc30bd75d0f651671e6de0b 
ENV JENKINS_UC https://updates.jenkins.io 
ENV COPY_REFERENCE_FILE_LOG $JENKINS_HOME/copy_reference_file.log 
ENV JAVA_OPTS="-Xmx8192m" 
ENV JENKINS_OPTS="--handlerCountMax=300 --logfile=/var/log/jenkins/jenkins.log --webroot=/var/cache/jenkins/war" 
    # Can be used to customize where jenkins.war get downloaded from 
ARG JENKINS_URL=http://repo.jenkins-ci.org/public/org/jenkins-ci/main/jenkins-war/${JENKINS_VERSION}/jenkins-war-${JENKINS_VERSION}.war 
ARG user=jenkins 
ARG group=jenkins 
ARG uid=1000 
ARG gid=1000 

# Jenkins is run with user `jenkins`, uid = 1000. If you bind mount a volume from the host or a data 
# container, ensure you use the same uid. 
RUN groupadd -g ${gid} ${group} \ 
    && useradd -d "$JENKINS_HOME" -u ${uid} -g ${gid} -m -s /bin/bash ${user} 

# Jenkins home directory is a volume, so configuration and build history 
# can be persisted and survive image upgrades 
VOLUME /var/jenkins_home 

# `/usr/share/jenkins/ref/` contains all reference configuration we want 
# to set on a fresh new installation. Use it to bundle additional plugins 
# or config file with your custom jenkins Docker image. 
RUN mkdir -p /usr/share/jenkins/ref/init.groovy.d 

# Install Jenkins. Could use ADD but this one does not check Last-Modified header neither does it 
# allow to control checksum. see https://github.com/docker/docker/issues/8331 
RUN curl -fsSL ${JENKINS_URL} -o /usr/share/jenkins/jenkins.war \ 
    && echo "${JENKINS_SHA} /usr/share/jenkins/jenkins.war" | sha1sum -c - 

# Prep Jenkins Directories 
USER root 
RUN chown -R ${user} "$JENKINS_HOME" /usr/share/jenkins/ref 
RUN mkdir /var/log/jenkins 
RUN mkdir /var/cache/jenkins 
RUN chown -R ${group}:${user} /var/log/jenkins 
RUN chown -R ${group}:${user} /var/cache/jenkins 

# Expose ports for web (8080) & node (50000) agents 
EXPOSE 8080 
EXPOSE 50000 

# Copy in local config filesfiles 
COPY init.groovy /usr/share/jenkins/ref/init.groovy.d/tcp-slave-agent-port.groovy 
COPY jenkins-support /usr/local/bin/jenkins-support 
COPY jenkins.sh /usr/local/bin/jenkins.sh 
    # NOTE : Just set pluginID to download latest version of plugin. 
    # NOTE : All plugins need to be listed as there is no transitive dependency resolution. 
    # from a derived Dockerfile, can use `RUN plugins.sh active.txt` to setup 
    # /usr/share/jenkins/ref/plugins from a support bundle 
COPY plugins.sh /usr/local/bin/plugins.sh 
RUN chmod +x /usr/local/bin/plugins.sh 
RUN chmod +x /usr/local/bin/jenkins.sh 

# Switch to the jenkins user 
USER ${user} 

# Tini as the entry point to manage zombie processes 
ENTRYPOINT ["/bin/tini", "--", "/usr/local/bin/jenkins.sh"] 

Answer 1

Essayez un JAVA_DEBIAN_VERSION de 8u111-b14-2~bpo8+1

Voici ce qui se passe: lorsque vous créez le fichier docker, docker tente d'exécuter toutes les lignes du dockerfile. Une de ces commandes est apt: apt-get install -y openjdk-8-jdk="$JAVA_DEBIAN_VERSION". Cette commande indique "Installer OpenJDK version $ JAVA_DEBIAN_VERSION, exactement, rien d'autre.". Cette version n'est plus disponible dans les dépôts Debian, elle ne peut donc pas être installée correctement! Je crois que cela se produit avec tous les paquets dans les miroirs officiels: si une nouvelle version du paquet est libérée, l'ancienne version n'est plus là pour être installée.

Si vous voulez accéder à des paquets Debian plus anciens, vous pouvez utiliser quelque chose comme http://snapshot.debian.org/. L'ancien paquet OpenJDK a vulnérabilités de sécurité connues. Je recommande d'utiliser la dernière version.

Vous pouvez utiliser la dernière version en omettant la version explicite dans la commande apt-get. D'un autre côté, cela rendra votre image moins reproductible: la construction de l'image aujourd'hui peut vous donner un résultat, la construire demain peut vous donner u112. En ce qui concerne la raison pour laquelle les instructions ont fonctionné dans l'autre Dockerfile, je pense que la raison en est qu'au moment où l'autre Dockerfile a été construit, le paquet était disponible. Donc docker pourrait apt-get install. Docker a ensuite construit l'image contenant le (plus ancien) OpenJDK. Cette image est un fichier binaire, vous pouvez donc l'installer ou l'utiliser dans FROM sans aucun problème. Mais vous ne pouvez pas reproduire l'image: si vous essayez de construire la même image vous-même, vous rencontrerez les mêmes erreurs. Cela pose également un problème de mise à jour de sécurité: les images docker étant effectivement des binaires statiques (construites une fois, regroupées dans toutes les dépendances), elles ne reçoivent pas de mises à jour de sécurité une fois créées. Vous devez suivre les mises à jour de sécurité affectant vos images de docker et reconstruire les images de docker affectées.