Automated cherry pick of #19061

build/build-official-release.sh

@@ -74,9 +74,17 @@ echo "Cloned, building release."
 echo
 
 cd "${KUBE_BUILD_DIR}"
+
 export KUBE_RELEASE_RUN_TESTS=n
 export KUBE_SKIP_CONFIRMATIONS=y
+# In order to build docker images for a release and tag them appropriately we need
+# to set these two variables.
+export KUBE_DOCKER_REGISTRY="gcr.io/google_containers"
+export KUBE_DOCKER_IMAGE_TAG="${KUBE_RELEASE_VERSION}"
+
 make release
+# We don't want to include this in 'make release' as it'd slow down every day development cycle.
+REGISTRY="${KUBE_DOCKER_REGISTRY}" VERSION="${KUBE_DOCKER_IMAGE_TAG}" make -C cluster/images/hyperkube/ build
 
 if ${KUBE_BUILD_DIR}/cluster/kubectl.sh version | grep Client | grep dirty; then
   echo "!!! Tag at invalid point, or something else is bad. Build is dirty. Don't push this build." >&2

build/common.sh

@@ -699,6 +699,7 @@ function kube::release::package_server_tarballs() {
   local platform
   for platform in "${KUBE_SERVER_PLATFORMS[@]}" ; do
     local platform_tag=${platform/\//-} # Replace a "/" for a "-"
+    local arch=$(basename ${platform})
     kube::log::status "Building tarball: server $platform_tag"
 
     local release_stage="${RELEASE_STAGE}/server/${platform_tag}/kubernetes"
@@ -712,7 +713,7 @@ function kube::release::package_server_tarballs() {
     cp "${KUBE_SERVER_BINARIES[@]/#/${LOCAL_OUTPUT_BINPATH}/${platform}/}" \
       "${release_stage}/server/bin/"
 
-    kube::release::create_docker_images_for_server "${release_stage}/server/bin";
+    kube::release::create_docker_images_for_server "${release_stage}/server/bin" "${arch}"
     kube::release::write_addon_docker_images_for_server "${release_stage}/addons"
 
     # Include the client binaries here too as they are useful debugging tools.
@@ -748,9 +749,16 @@ function kube::release::sha1() {
 
 # This will take binaries that run on master and creates Docker images
 # that wrap the binary in them. (One docker image per binary)
+# Args:
+#  $1 - binary_dir, the directory to save the tared images to.
+#  $2 - arch, architecture for which we are building docker images.
+# Globals:
+#   KUBE_DOCKER_WRAPPED_BINARIES
 function kube::release::create_docker_images_for_server() {
   # Create a sub-shell so that we don't pollute the outer environment
   (
+    local binary_dir="$1"
+    local arch="$2"
     local binary_name
     for binary_name in "${KUBE_DOCKER_WRAPPED_BINARIES[@]}"; do
       kube::log::status "Starting Docker build for image: ${binary_name}"
@@ -769,12 +777,20 @@ function kube::release::create_docker_images_for_server() {
         printf " FROM busybox \n ADD ${binary_name} /usr/local/bin/${binary_name}\n" > ${docker_file_path}
 
         local docker_image_tag=gcr.io/google_containers/$binary_name:$md5_sum
-        docker build -q -t "${docker_image_tag}" ${docker_build_path} >/dev/null
-        docker save ${docker_image_tag} > ${1}/${binary_name}.tar
-        echo $md5_sum > ${1}/${binary_name}.docker_tag
+        "${DOCKER[@]}" build -q -t "${docker_image_tag}" ${docker_build_path} >/dev/null
+        "${DOCKER[@]}" save ${docker_image_tag} > ${binary_dir}/${binary_name}.tar
+        echo $md5_sum > ${binary_dir}/${binary_name}.docker_tag
 
         rm -rf ${docker_build_path}
 
+        # If we are building an official/alpha/beta release we want to keep docker images
+        # and tag them appropriately.
+        if [[ -n "${KUBE_DOCKER_IMAGE_TAG-}" && -n "${KUBE_DOCKER_REGISTRY-}" ]]; then
+          local release_docker_image_tag="${KUBE_DOCKER_REGISTRY}/${binary_name}-${arch}:${KUBE_DOCKER_IMAGE_TAG}"
+          kube::log::status "Tagging docker image ${docker_image_tag} as ${release_docker_image_tag}"
+          "${DOCKER[@]}" tag -f "${docker_image_tag}" "${release_docker_image_tag}" 2>/dev/null
+        fi
+
         kube::log::status "Deleting docker image ${docker_image_tag}"
         "${DOCKER[@]}" rmi ${docker_image_tag} 2>/dev/null || true
       ) &
@@ -1365,3 +1381,41 @@ function kube::release::gcs::publish() {
     return 1
   fi
 }
+
+# ---------------------------------------------------------------------------
+# Docker Release
+
+# Releases all docker images to a docker registry specified by KUBE_DOCKER_REGISTRY
+# using tag KUBE_DOCKER_IMAGE_TAG.
+#
+# Globals:
+#   KUBE_DOCKER_REGISTRY
+#   KUBE_DOCKER_IMAGE_TAG
+# Returns:
+#   If new pushing docker images was successful.
+function kube::release::docker::release() {
+  local binaries=(
+    "kube-apiserver"
+    "kube-controller-manager"
+    "kube-scheduler"
+    "kube-proxy"
+    "hyperkube"
+  )
+
+  local archs=(
+    "amd64"
+  )
+
+  local docker_push_cmd=("docker")
+  if [[ "${KUBE_DOCKER_REGISTRY}" == "gcr.io/"* ]]; then
+    docker_push_cmd=("gcloud" "docker")
+  fi
+
+  for arch in "${archs[@]}"; do
+    for binary in "${binaries[@]}"; do
+      local docker_target="${KUBE_DOCKER_REGISTRY}/${binary}-${arch}:${KUBE_DOCKER_IMAGE_TAG}"
+      kube::log::status "Pushing ${binary} to ${docker_target}"
+      "${docker_push_cmd[@]}" push "${docker_target}"
+    done
+  done
+}

build/push-official-release.sh

@@ -34,6 +34,9 @@ KUBE_GCS_RELEASE_BUCKET='kubernetes-release'
 KUBE_GCS_RELEASE_PREFIX="release/${KUBE_RELEASE_VERSION}"
 KUBE_GCS_PUBLISH_VERSION="${KUBE_RELEASE_VERSION}"
 
+KUBE_DOCKER_REGISTRY="gcr.io/google_containers"
+KUBE_DOCKER_IMAGE_TAG="${KUBE_RELEASE_VERSION}"
+
 KUBE_ROOT="$(dirname "${BASH_SOURCE}")/.."
 source "${KUBE_ROOT}/build/common.sh"
 
@@ -44,4 +47,5 @@ fi
 
 kube::release::parse_and_validate_release_version "${KUBE_RELEASE_VERSION}"
 kube::release::gcs::release
+kube::release::docker::release
 kube::release::gcs::publish_official 'latest'

cluster/images/hyperkube/Makefile

@@ -1,12 +1,41 @@
-# build the hyperkube image.
+# Build the hyperkube image.
+#
+# Usage:
+#   VERSION=v1.1.2 [REGISTRY="gcr.io/google_containers"] make build
 
-VERSION=v1.0.1
+REGISTRY?="gcr.io/google_containers"
+ARCH=amd64
+BASEIMAGE=debian:jessie
+TEMP_DIR:=$(shell mktemp -d)
 
-all:
-	cp ../../saltbase/salt/helpers/safe_format_and_mount .
-	curl -O https://storage.googleapis.com/kubernetes-release/release/${VERSION}/bin/linux/amd64/hyperkube
-	sed -i "s/VERSION/${VERSION}/g" master-multi.json master.json
-	docker build -t gcr.io/google_containers/hyperkube:${VERSION} .
-	gcloud docker push gcr.io/google_containers/hyperkube:${VERSION}
+## Comment in for arm builds, must be run on an arm machine
+# ARCH=arm
+# need to escape '/' for the regexp below
+# BASEIMAGE=armbuild\\/debian:jessie
+
+all: build
+
+build:
+ifndef VERSION
+    $(error VERSION is undefined)
+endif
+	cp ./* ${TEMP_DIR}
+	cp ../../saltbase/salt/helpers/safe_format_and_mount ${TEMP_DIR}
+	cp ../../saltbase/salt/generate-cert/make-ca-cert.sh ${TEMP_DIR}
+	cp ../../../_output/dockerized/bin/linux/${ARCH}/hyperkube ${TEMP_DIR}
+	cd ${TEMP_DIR} && sed -i "s/VERSION/${VERSION}/g" master-multi.json master.json kube-proxy.json
+	cd ${TEMP_DIR} && sed -i "s/ARCH/${ARCH}/g" master-multi.json master.json kube-proxy.json
+	cd ${TEMP_DIR} && sed -i "s/BASEIMAGE/${BASEIMAGE}/g" Dockerfile
+	docker build -t ${REGISTRY}/hyperkube-${ARCH}:${VERSION} ${TEMP_DIR}
+	# Backward compatability.  TODO: deprecate this image tag
+ifeq ($(ARCH),amd64)
+	docker tag -f ${REGISTRY}/hyperkube-${ARCH}:${VERSION} ${REGISTRY}/hyperkube:${VERSION}
+endif
+
+push: build
+	gcloud docker push ${REGISTRY}/hyperkube-${ARCH}:${VERSION}
+ifeq ($(ARCH),amd64)
+	gcloud docker push ${REGISTRY}/hyperkube:${VERSION}
+endif
 
 .PHONY: all