Add CentOS based images for 2.0 (#134)

Author: tmds

2.0/build/Dockerfile

@@ -0,0 +1,55 @@
+FROM centos/dotnet-20-runtime-centos7
+# This image provides a .NET Core 2.0 environment you can use to run your .NET
+# applications.
+
+# Default to UTF-8 file.encoding
+ENV PATH=/opt/app-root/src/.local/bin:/opt/app-root/src/bin:/opt/app-root/node_modules/.bin:${PATH} \
+    STI_SCRIPTS_PATH=/usr/libexec/s2i
+
+LABEL io.k8s.description="Platform for building and running .NET Core 2.0 applications" \
+      io.k8s.display-name=".NET Core 2.0" \
+      io.openshift.s2i.scripts-url=image:///usr/libexec/s2i \
+      io.openshift.tags="builder,.net,dotnet,dotnetcore,rh-dotnet20" \
+      io.openshift.expose-services="8080:http" \
+      io.s2i.scripts-url=image:///usr/libexec/s2i
+
+# Labels consumed by Red Hat build service
+LABEL name="centos/dotnet-20-centos7" \
+      com.redhat.component="rh-dotnet20-docker" \
+      version="2.0" \
+      release="1" \
+      architecture="x86_64"
+
+# Labels consumed by Eclipse JBoss OpenShift plugin
+LABEL com.redhat.dev-mode="DEV_MODE:false" \
+      com.redhat.deployments-dir="/opt/app-root/src"
+
+# Switch to root for package installs
+USER 0
+
+# Copy the S2I scripts from the specific language image to $STI_SCRIPTS_PATH.
+COPY ./s2i/bin/ /usr/libexec/s2i
+
+RUN yum install -y centos-release-dotnet centos-release-scl-rh && \
+    INSTALL_PKGS="rh-nodejs6-npm rh-nodejs6-nodejs-nodemon rh-dotnet20-dotnet-sdk-2.0 rsync" && \
+    yum install -y --setopt=tsflags=nodocs $INSTALL_PKGS && \
+    rpm -V $INSTALL_PKGS && \
+    yum clean all -y
+
+# Directory with the sources is set as the working directory.
+RUN mkdir /opt/app-root/src
+WORKDIR /opt/app-root/src
+
+# Since $HOME is set to /opt/app-root, the yum install may have created config
+# directories (such as ~/.pki/nssdb) there. These will be owned by root and can
+# cause actions that work on all of /opt/app-root to fail. So we need to fix
+# the permissions on those too.
+RUN chown -R 1001:0 /opt/app-root && fix-permissions /opt/app-root
+
+ENV ENABLED_COLLECTIONS="$ENABLED_COLLECTIONS rh-nodejs6"
+
+# Run container by default as user with id 1001 (default)
+USER 1001
+
+# Set the default CMD to print the usage of the language image.
+CMD /usr/libexec/s2i/usage

2.0/build/README.md

@@ -13,8 +13,6 @@ To build a simple [dotnet-sample-app](test/asp-net-hello-world) application
 using standalone [S2I](https://github.com/openshift/source-to-image) and then run the
 resulting image with [Docker](http://docker.io) execute:
 
-*  **For RHEL based image**
-
     ```
     $ sudo s2i build git://github.com/redhat-developer/s2i-dotnetcore --context-dir=2.0/test/asp-net-hello-world dotnet/dotnet-20-rhel7 dotnet-sample-app
     $ sudo docker run -p 8080:8080 dotnet-sample-app
@@ -36,6 +34,10 @@ Repository organization
   RHEL based Dockerfile. In order to perform build or test actions on this
   Dockerfile you need to run the action on a properly subscribed RHEL machine.
 
+* **Dockerfile**
+
+  CentOS based Dockerfile.
+
 * **`root/usr/bin/`**
 
   This folder contains common scripts.

2.0/runtime/Dockerfile

@@ -0,0 +1,78 @@
+FROM centos:7
+# This image provides a .NET Core 2.0 environment you can use to run your .NET
+# applications.
+
+EXPOSE 8080
+
+ENV DOTNET_CORE_VERSION=2.0
+
+# Default to UTF-8 file.encoding
+ENV LANG=C.UTF-8 \
+    HOME=/opt/app-root \
+    PATH=/opt/app-root/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin \
+    DOTNET_APP_PATH=/opt/app-root/app \
+    DOTNET_DEFAULT_CMD=default-cmd.sh
+
+LABEL io.k8s.description="Platform for running .NET Core 2.0 applications" \
+      io.k8s.display-name=".NET Core 2.0" \
+      io.openshift.tags="runtime,.net,dotnet,dotnetcore,rh-dotnet20-runtime" \
+      io.openshift.expose-services="8080:http"
+
+# Labels consumed by Red Hat build service
+LABEL name="centos/dotnet-20-runtime-centos7" \
+      com.redhat.component="rh-dotnet20-runtime-docker" \
+      version="2.0" \
+      release="1" \
+      architecture="x86_64"
+
+# Don't download/extract docs for nuget packages
+ENV NUGET_XMLDOC_MODE=skip
+
+# Don't do initially populate of package cache
+ENV DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
+
+## By default, ASP.NET Core runs on port 5000. We configure it to match
+## the container port.
+ENV ASPNETCORE_URLS=http://*:8080
+
+# Each language image can have 'contrib' a directory with extra files needed to
+# run and build the applications.
+COPY ./contrib/ /opt/app-root
+
+COPY ./root/usr/bin /usr/bin
+
+RUN yum install -y centos-release-dotnet && \
+    INSTALL_PKGS="rh-dotnet20-dotnet-runtime-2.0 nss_wrapper tar unzip" && \
+    yum install -y --setopt=tsflags=nodocs $INSTALL_PKGS && \
+    rpm -V $INSTALL_PKGS && \
+    yum clean all -y
+
+# Get prefix path and path to scripts rather than hard-code them in scripts
+ENV CONTAINER_SCRIPTS_PATH=/opt/app-root \
+    ENABLED_COLLECTIONS="rh-dotnet20"
+
+# When bash is started non-interactively, to run a shell script, for example it
+# looks for this variable and source the content of this file. This will enable
+# the SCL for all scripts without need to do 'scl enable'.
+ENV BASH_ENV=${CONTAINER_SCRIPTS_PATH}/etc/scl_enable \
+    ENV=${CONTAINER_SCRIPTS_PATH}/etc/scl_enable \
+    PROMPT_COMMAND=". ${CONTAINER_SCRIPTS_PATH}/etc/scl_enable"
+
+# Add default user
+RUN mkdir -p ${DOTNET_APP_PATH} && \
+    useradd -u 1001 -r -g 0 -d ${HOME} -s /sbin/nologin \
+      -c "Default Application User" default
+
+WORKDIR ${DOTNET_APP_PATH}
+COPY default-cmd.sh ${DOTNET_DEFAULT_CMD}
+CMD "./${DOTNET_DEFAULT_CMD}"
+
+# In order to drop the root user, we have to make some directories world
+# writable as OpenShift default security model is to run the container under
+# random UID.
+RUN chown -R 1001:0 /opt/app-root && fix-permissions /opt/app-root
+
+ENTRYPOINT [ "container-entrypoint" ]
+
+# Run container by default as user with id 1001 (default)
+USER 1001

2.0/runtime/README.md

@@ -46,6 +46,10 @@ Repository organization
   RHEL based Dockerfile. In order to perform build or test actions on this
   Dockerfile you need to run the action on a properly subscribed RHEL machine.
 
+* **Dockerfile**
+
+  CentOS based Dockerfile.
+
 * **`test/`**
 
   This folder contains binary archives of [S2I](https://github.com/openshift/source-to-image)

README.md

@@ -8,26 +8,26 @@ image can be run using [Docker](http://docker.io).
 
 Versions
 ----------------
+
 .NET Core versions currently provided are:
-* 1.0
-* 1.1
-* 2.0
 
-RHEL versions currently supported are:
-* RHEL 7
+* 1.0 (RHEL 7)
+* 1.1 (RHEL 7)
+* 2.0 (RHEL 7, CentOS 7)
 
-Installation
-----------------
 
-To build a RHEL 7 based .NET Core image, you need to run the build on a
-properly subscribed RHEL machine.
+Building
+----------------
 
 ```
 $ git clone https://github.com/redhat-developer/s2i-dotnetcore.git
-$ cd s2i-dotnetcore/1.0
-$ sudo docker build -f Dockerfile.rhel7 -t dotnet/dotnetcore-10-rhel7 .
+$ sudo VERSIONS=2.0 ./build.sh
 ```
 
+Note: to build RHEL 7 based images, you need to run the build on a
+properly subscribed RHEL machine. To build CentOS images on RHEL, set
+BUILD_CENTOS=true. On non-RHEL, building CentOS images is the default.
+
 Usage
 ---------------------------------
 
@@ -43,13 +43,15 @@ see [1.0 usage documentation](1.0/README.md).
 
 Image name structure
 ------------------------
-##### Structure: dotnet/1-2-3
 
-1. Platform name (lowercase) - dotnetcore
-2. Platform version (without dots) - 10
-3. Base builder image - rhel7
+##### Structure: 1/2-3-4
+
+1. Prefix: 'dotnet' for RHEL, 'centos' for CentOS
+2. Platform name: 'dotnetcore' for 1.x, 'dotnet' for 2.0+
+3. Platform version (without dots)
+4. Base builder image: 'rhel7' or 'centos7'
 
-Example: `dotnet/dotnetcore-10-rhel7`
+Examples: `dotnet/dotnetcore-10-rhel7`, `centos/dotnet-20-centos7`
 
 OpenShift Templates
 -------------------

build.sh

@@ -13,6 +13,8 @@
 #
 # VERSIONS     The list of versions to build/test.
 #              Defaults to all versions. i.e "1.0 1.1".
+#
+# BUILD_CENTOS    If 'true' build CentOS based images.
 # -----------------------------------------------------
 #
 # Usage:
@@ -49,36 +51,54 @@ check_result_msg() {
 
 build_image() {
   local path=$1
-  local name=$2
+  local docker_filename=$2
+  local name=$3
   if ! image_exists ${name}; then
     echo "Building Docker image ${name} ..."
     if [ ! -d "${path}" ]; then
       echo "No directory found at given location '${path}'. Skipping this image."
       return
     fi
     pushd ${path} &>/dev/null
-      docker build -f Dockerfile.rhel7 -t ${name} .
+      docker build -f ${docker_filename} -t ${name} .
       check_result_msg $? "Building Docker image ${name} FAILED!"
     popd &>/dev/null
   fi
 }
 
 test_images() {
   local path=$1
+  local test_image=$2
+  local runtime_image=$3
   echo "Running tests..."
-  ${path}/run
+  IMAGE_NAME=${test_image} RUNTIME_IMAGE_NAME=${runtime_image} ${path}/run
   check_result_msg $? "Tests FAILED!"
 }
 
-VERSIONS="${VERSIONS:-1.0 1.1 2.0}"
+# Default to CentOS when not on RHEL.
+if ! [[ `grep "Red Hat Enterprise Linux" /etc/redhat-release` ]]; then
+  BUILD_CENTOS=true
+fi
+
+if [ "$BUILD_CENTOS" = "true" ]; then
+  VERSIONS="${VERSIONS:-2.0}"
+  image_os="centos7"
+  image_prefix="centos"
+  docker_filename="Dockerfile"
+else
+  VERSIONS="${VERSIONS:-1.0 1.1 2.0}"
+  image_prefix="dotnet"
+  image_os="rhel7"
+  docker_filename="Dockerfile.rhel7"
+fi
 
 for v in ${VERSIONS}; do
   if [ "$v" == "1.0" ] || [ "$v" == "1.1" ]; then
-    build_name="dotnet/$(base_image_name ${v})-rhel7"
+    build_name="${image_prefix}/$(base_image_name ${v})-${image_os}"
 
     # Build the build image
-    build_image "${v}" "${build_name}"
-    test_images "${v}/test"
+    build_image "${v}" "${docker_filename}" "${build_name}"
+    test_images "${v}/test" "${build_name}"
 
     if [ "$TEST_OPENSHIFT" = "true" ]; then
       build_name="registry.access.redhat.com/${build_name}:latest"
@@ -89,16 +109,16 @@ for v in ${VERSIONS}; do
       popd &>/dev/null
     fi
   else
-    build_name="dotnet/$(base_image_name ${v})-rhel7"
-    runtime_name="dotnet/$(base_image_name ${v})-runtime-rhel7"
+    build_name="${image_prefix}/$(base_image_name ${v})-${image_os}"
+    runtime_name="${image_prefix}/$(base_image_name ${v})-runtime-${image_os}"
 
     # Build the runtime image
-    build_image "${v}/runtime" "${runtime_name}"
-    test_images "${v}/runtime/test"
+    build_image "${v}/runtime" "${docker_filename}" "${runtime_name}"
+    test_images "${v}/runtime/test" "${runtime_name}"
 
     # Build the build image
-    build_image "${v}/build" "${build_name}"
-    test_images "${v}/build/test"
+    build_image "${v}/build" "${docker_filename}" "${build_name}"
+    test_images "${v}/build/test" "${build_name}" "${runtime_name}"
 
     if [ "$TEST_OPENSHIFT" = "true" ]; then
       build_name="registry.access.redhat.com/${build_name}:latest"