IntenseWebs/grafana
3
0
Fork 0
mirror of https://github.com/grafana/grafana.git synced 2025-02-25 18:55:37 -06:00
Code Issues Packages Projects Releases Wiki Activity

Build: Streamline and sync dockerfiles (#58101)

Browse Source 
* streamline and sync dockerfiles

* improve go dependency cacheability

* unify alpine and ubuntu Dockerfiles

* include glibc support in locally-built alpine images
This commit is contained in:
Dan Cech
2022-11-28 14:43:42 -05:00
committed by GitHub
parent 84ec35a4ad
commit 9fec54df2d
12 changed files with 270 additions and 346 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.github/pr-commands.json vendored
View File

@@ -67,7 +67,6 @@
"scripts/*.sh", "scripts/*.sh",
"Makefile", "Makefile",
"Dockerfile", "Dockerfile",
"Dockerfile.ubuntu"
], ],
"action": "updateLabel", "action": "updateLabel",
"addLabel": "type/build-packaging" "addLabel": "type/build-packaging"

139
Dockerfile
View File

@@ -1,8 +1,21 @@
FROM node:16-alpine3.15 as js-builder ######################## IMPORTANT ########################
#
# There are 2 Dockerfiles which must be kept in sync:
#
# - Dockerfile
# - packaging/docker/Dockerfile
#
###########################################################
ARG BASE_IMAGE=alpine:3.15
ARG JS_IMAGE=node:16-alpine3.15
ARG GO_IMAGE=golang:1.19.3-alpine3.15
FROM ${JS_IMAGE} as js-builder
ENV NODE_OPTIONS=--max_old_space_size=8000 ENV NODE_OPTIONS=--max_old_space_size=8000
WORKDIR /grafana WORKDIR /tmp/grafana
COPY package.json yarn.lock .yarnrc.yml ./ COPY package.json yarn.lock .yarnrc.yml ./
COPY .yarn .yarn COPY .yarn .yarn
@@ -13,82 +26,122 @@ RUN yarn install
COPY tsconfig.json .eslintrc .editorconfig .browserslistrc .prettierrc.js babel.config.json .linguirc ./ COPY tsconfig.json .eslintrc .editorconfig .browserslistrc .prettierrc.js babel.config.json .linguirc ./
COPY public public COPY public public
COPY tools tools
COPY scripts scripts COPY scripts scripts
COPY emails emails COPY emails emails
ENV NODE_ENV production ENV NODE_ENV production
RUN yarn build RUN yarn build
FROM golang:1.19.3-alpine3.15 as go-builder FROM ${GO_IMAGE} as go-builder
RUN apk add --no-cache gcc g++ make # Install build dependencies
RUN if grep -i -q alpine /etc/issue; then \
apk add --no-cache gcc g++ make; \
fi
WORKDIR /grafana WORKDIR /tmp/grafana
COPY go.mod go.sum embed.go Makefile build.go package.json ./ COPY go.* ./
COPY .bingo .bingo
RUN go mod download && \
go install github.com/bwplotka/bingo@latest && \
bingo get
COPY embed.go Makefile build.go package.json ./
COPY cue.mod cue.mod
COPY kinds kinds
COPY packages/grafana-schema packages/grafana-schema COPY packages/grafana-schema packages/grafana-schema
COPY public/app/plugins public/app/plugins COPY public/app/plugins public/app/plugins
COPY public/api-spec.json public/api-spec.json COPY public/api-spec.json public/api-spec.json
COPY pkg pkg COPY pkg pkg
COPY scripts scripts COPY scripts scripts
COPY cue.mod cue.mod
COPY .bingo .bingo
RUN go mod verify
RUN make build-go RUN make build-go
# Final stage # Final stage
FROM alpine:3.15.6 FROM ${BASE_IMAGE}
LABEL maintainer="Grafana team <hello@grafana.com>" LABEL maintainer="Grafana Labs <hello@grafana.com>"
ARG GF_UID="472" ARG GF_UID="472"
ARG GF_GID="0" ARG GF_GID="0"
ENV PATH="/usr/share/grafana/bin:$PATH" \ ENV PATH="/usr/share/grafana/bin:$PATH" \
GF_PATHS_CONFIG="/etc/grafana/grafana.ini" \ GF_PATHS_CONFIG="/etc/grafana/grafana.ini" \
GF_PATHS_DATA="/var/lib/grafana" \ GF_PATHS_DATA="/var/lib/grafana" \
GF_PATHS_HOME="/usr/share/grafana" \ GF_PATHS_HOME="/usr/share/grafana" \
GF_PATHS_LOGS="/var/log/grafana" \ GF_PATHS_LOGS="/var/log/grafana" \
GF_PATHS_PLUGINS="/var/lib/grafana/plugins" \ GF_PATHS_PLUGINS="/var/lib/grafana/plugins" \
GF_PATHS_PROVISIONING="/etc/grafana/provisioning" GF_PATHS_PROVISIONING="/etc/grafana/provisioning"
WORKDIR $GF_PATHS_HOME WORKDIR $GF_PATHS_HOME
RUN apk add --no-cache ca-certificates bash tzdata musl-utils # Install dependencies
RUN apk info -vv | sort RUN if grep -i -q alpine /etc/issue; then \
apk add --no-cache ca-certificates bash tzdata musl-utils && \
apk info -vv | sort; \
elif grep -i -q ubuntu /etc/issue; then \
DEBIAN_FRONTEND=noninteractive && \
apt-get update && \
apt-get install -y ca-certificates curl tzdata && \
apt-get autoremove -y && \
rm -rf /var/lib/apt/lists/*; \
else \
echo 'ERROR: Unsupported base image' && /bin/false; \
fi
# glibc support for alpine x86_64 only
RUN if grep -i -q alpine /etc/issue && [ `arch` = "x86_64" ]; then \
wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.35-r0/glibc-2.35-r0.apk \
-O /tmp/glibc-2.35-r0.apk && \
wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.35-r0/glibc-bin-2.35-r0.apk \
-O /tmp/glibc-bin-2.35-r0.apk && \
apk add --no-cache --allow-untrusted /tmp/glibc-2.35-r0.apk /tmp/glibc-bin-2.35-r0.apk && \
rm -f /lib64/ld-linux-x86-64.so.2 && \
ln -s /usr/glibc-compat/lib64/ld-linux-x86-64.so.2 /lib64/ld-linux-x86-64.so.2 && \
rm -f /tmp/glibc-2.35-r0.apk && \
rm -f /tmp/glibc-bin-2.35-r0.apk && \
rm -f /lib/ld-linux-x86-64.so.2 && \
rm -f /etc/ld.so.cache; \
fi
COPY conf ./conf COPY conf ./conf
RUN if [ ! $(getent group "$GF_GID") ]; then \ RUN if [ ! $(getent group "$GF_GID") ]; then \
addgroup -S -g $GF_GID grafana; \ if grep -i -q alpine /etc/issue; then \
fi addgroup -S -g $GF_GID grafana; \
else \
addgroup --system --gid $GF_GID grafana; \
fi; \
fi && \
GF_GID_NAME=$(getent group $GF_GID | cut -d':' -f1) && \
mkdir -p "$GF_PATHS_HOME/.aws" && \
if grep -i -q alpine /etc/issue; then \
adduser -S -u $GF_UID -G "$GF_GID_NAME" grafana; \
else \
adduser --system --uid $GF_UID --ingroup "$GF_GID_NAME" grafana; \
fi && \
mkdir -p "$GF_PATHS_PROVISIONING/datasources" \
"$GF_PATHS_PROVISIONING/dashboards" \
"$GF_PATHS_PROVISIONING/notifiers" \
"$GF_PATHS_PROVISIONING/plugins" \
"$GF_PATHS_PROVISIONING/access-control" \
"$GF_PATHS_PROVISIONING/alerting" \
"$GF_PATHS_LOGS" \
"$GF_PATHS_PLUGINS" \
"$GF_PATHS_DATA" && \
cp conf/sample.ini "$GF_PATHS_CONFIG" && \
cp conf/ldap.toml /etc/grafana/ldap.toml && \
chown -R "grafana:$GF_GID_NAME" "$GF_PATHS_DATA" "$GF_PATHS_HOME/.aws" "$GF_PATHS_LOGS" "$GF_PATHS_PLUGINS" "$GF_PATHS_PROVISIONING" && \
chmod -R 777 "$GF_PATHS_DATA" "$GF_PATHS_HOME/.aws" "$GF_PATHS_LOGS" "$GF_PATHS_PLUGINS" "$GF_PATHS_PROVISIONING"
RUN export GF_GID_NAME=$(getent group $GF_GID | cut -d':' -f1) && \ COPY --from=go-builder /tmp/grafana/bin/*/grafana-server /tmp/grafana/bin/*/grafana-cli /tmp/grafana/bin/*/grafana ./bin/
mkdir -p "$GF_PATHS_HOME/.aws" && \ COPY --from=js-builder /tmp/grafana/public ./public
adduser -S -u $GF_UID -G "$GF_GID_NAME" grafana && \
mkdir -p "$GF_PATHS_PROVISIONING/datasources" \
"$GF_PATHS_PROVISIONING/dashboards" \
"$GF_PATHS_PROVISIONING/notifiers" \
"$GF_PATHS_PROVISIONING/plugins" \
"$GF_PATHS_PROVISIONING/access-control" \
"$GF_PATHS_PROVISIONING/alerting" \
"$GF_PATHS_LOGS" \
"$GF_PATHS_PLUGINS" \
"$GF_PATHS_DATA" && \
cp "$GF_PATHS_HOME/conf/sample.ini" "$GF_PATHS_CONFIG" && \
cp "$GF_PATHS_HOME/conf/ldap.toml" /etc/grafana/ldap.toml && \
chown -R "grafana:$GF_GID_NAME" "$GF_PATHS_DATA" "$GF_PATHS_HOME/.aws" "$GF_PATHS_LOGS" "$GF_PATHS_PLUGINS" "$GF_PATHS_PROVISIONING" && \
chmod -R 777 "$GF_PATHS_DATA" "$GF_PATHS_HOME/.aws" "$GF_PATHS_LOGS" "$GF_PATHS_PLUGINS" "$GF_PATHS_PROVISIONING"
COPY --from=go-builder /grafana/bin/*/grafana-server /grafana/bin/*/grafana-cli /grafana/bin/*/grafana ./bin/
COPY --from=js-builder /grafana/public ./public
COPY --from=js-builder /grafana/tools ./tools
EXPOSE 3000 EXPOSE 3000
COPY ./packaging/docker/run.sh /run.sh COPY ./packaging/docker/run.sh /run.sh
USER grafana USER "$GF_UID"
ENTRYPOINT [ "/run.sh" ] ENTRYPOINT [ "/run.sh" ]

87
Dockerfile.ubuntu
View File

@@ -1,87 +0,0 @@
FROM node:16-alpine3.15 as js-builder
ENV NODE_OPTIONS=--max_old_space_size=8000
WORKDIR /usr/src/app/
COPY package.json yarn.lock ./
COPY packages packages
COPY .yarnrc.yml ./
COPY .yarn .yarn
COPY plugins-bundled plugins-bundled
RUN yarn install
COPY tsconfig.json .eslintrc .editorconfig .browserslistrc .prettierrc.js babel.config.json .linguirc ./
COPY public public
COPY tools tools
COPY scripts scripts
COPY emails emails
ENV NODE_ENV production
RUN yarn build
FROM golang:1.19.3 AS go-builder
WORKDIR /src/grafana
COPY go.mod go.sum embed.go ./
COPY Makefile build.go package.json ./
COPY .bingo .bingo
COPY pkg pkg/
COPY cue.mod cue.mod/
COPY packages/grafana-schema packages/grafana-schema/
COPY public/app/plugins public/app/plugins/
COPY public/api-spec.json public/api-spec.json
RUN go mod verify
RUN make build-go
FROM ubuntu:20.04
LABEL maintainer="Grafana team <hello@grafana.com>"
EXPOSE 3000
ARG GF_UID="472"
ARG GF_GID="472"
ENV PATH="/usr/share/grafana/bin:$PATH" \
GF_PATHS_CONFIG="/etc/grafana/grafana.ini" \
GF_PATHS_DATA="/var/lib/grafana" \
GF_PATHS_HOME="/usr/share/grafana" \
GF_PATHS_LOGS="/var/log/grafana" \
GF_PATHS_PLUGINS="/var/lib/grafana/plugins" \
GF_PATHS_PROVISIONING="/etc/grafana/provisioning"
WORKDIR $GF_PATHS_HOME
COPY conf conf
# curl should be part of the image
RUN apt-get update && apt-get install -y ca-certificates curl
RUN mkdir -p "$GF_PATHS_HOME/.aws" && \
addgroup --system --gid $GF_GID grafana && \
adduser --uid $GF_UID --system --ingroup grafana grafana && \
mkdir -p "$GF_PATHS_PROVISIONING/datasources" \
"$GF_PATHS_PROVISIONING/dashboards" \
"$GF_PATHS_PROVISIONING/notifiers" \
"$GF_PATHS_PROVISIONING/plugins" \
"$GF_PATHS_PROVISIONING/access-control" \
"$GF_PATHS_PROVISIONING/alerting" \
"$GF_PATHS_LOGS" \
"$GF_PATHS_PLUGINS" \
"$GF_PATHS_DATA" && \
cp conf/sample.ini "$GF_PATHS_CONFIG" && \
cp conf/ldap.toml /etc/grafana/ldap.toml && \
chown -R grafana:grafana "$GF_PATHS_DATA" "$GF_PATHS_HOME/.aws" "$GF_PATHS_LOGS" "$GF_PATHS_PLUGINS" "$GF_PATHS_PROVISIONING" && \
chmod -R 777 "$GF_PATHS_DATA" "$GF_PATHS_HOME/.aws" "$GF_PATHS_LOGS" "$GF_PATHS_PLUGINS" "$GF_PATHS_PROVISIONING"
COPY --from=go-builder /src/grafana/bin/*/grafana-server /src/grafana/bin/*/grafana-cli /grafana/bin/*/grafana bin/
COPY --from=js-builder /usr/src/app/public public
COPY --from=js-builder /usr/src/app/tools tools
COPY packaging/docker/run.sh /
USER grafana
ENTRYPOINT [ "/run.sh" ]

9
Makefile
View File

@@ -158,12 +158,15 @@ shellcheck: $(SH_FILES) ## Run checks for shell scripts.
build-docker-full: ## Build Docker image for development. build-docker-full: ## Build Docker image for development.
@echo "build docker container" @echo "build docker container"
docker build --tag grafana/grafana:dev . docker build \
--tag grafana/grafana:dev .
build-docker-full-ubuntu: ## Build Docker image based on Ubuntu for development. build-docker-full-ubuntu: ## Build Docker image based on Ubuntu for development.
@echo "build docker container" @echo "build docker container"
docker build --tag grafana/grafana:dev-ubuntu -f ./Dockerfile.ubuntu . docker build \
--build-arg BASE_IMAGE=ubuntu:20.04 \
--build-arg GO_IMAGE=golang:1.19.3 \
--tag grafana/grafana:dev-ubuntu .
##@ Services ##@ Services

70
packaging/docker/Dockerfile
View File

@@ -1,22 +1,39 @@
######################## IMPORTANT ########################
#
# There are 2 Dockerfiles which must be kept in sync:
#
# - Dockerfile
# - packaging/docker/Dockerfile
#
###########################################################
ARG BASE_IMAGE=alpine:3.15 ARG BASE_IMAGE=alpine:3.15
FROM ${BASE_IMAGE}
FROM ${BASE_IMAGE} as tgz-builder
WORKDIR /tmp/grafana
ARG GRAFANA_TGZ="grafana-latest.linux-x64-musl.tar.gz" ARG GRAFANA_TGZ="grafana-latest.linux-x64-musl.tar.gz"
# Make sure we have Gnu tar # Make sure we have Gnu tar
RUN apk add --no-cache tar RUN if grep -i -q alpine /etc/issue; then \
apk add --no-cache tar; \
fi
COPY ${GRAFANA_TGZ} /tmp/grafana.tar.gz COPY ${GRAFANA_TGZ} /tmp/grafana.tar.gz
# Change to tar xfzv to make tar print every file it extracts # Change to tar xfzv to make tar print every file it extracts
RUN mkdir /tmp/grafana && tar xzf /tmp/grafana.tar.gz --strip-components=1 -C /tmp/grafana RUN tar xzf /tmp/grafana.tar.gz --strip-components=1 -C /tmp/grafana
# Final stage
FROM ${BASE_IMAGE} FROM ${BASE_IMAGE}
LABEL maintainer="Grafana Labs <hello@grafana.com>"
ARG GF_UID="472" ARG GF_UID="472"
ARG GF_GID="0" ARG GF_GID="0"
ENV PATH=/usr/share/grafana/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin \ ENV PATH="/usr/share/grafana/bin:$PATH" \
GF_PATHS_CONFIG="/etc/grafana/grafana.ini" \ GF_PATHS_CONFIG="/etc/grafana/grafana.ini" \
GF_PATHS_DATA="/var/lib/grafana" \ GF_PATHS_DATA="/var/lib/grafana" \
GF_PATHS_HOME="/usr/share/grafana" \ GF_PATHS_HOME="/usr/share/grafana" \
@@ -26,11 +43,22 @@ ENV PATH=/usr/share/grafana/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bi
WORKDIR $GF_PATHS_HOME WORKDIR $GF_PATHS_HOME
RUN apk add --no-cache ca-certificates bash tzdata musl-utils # Install dependencies
RUN apk info -vv | sort RUN if grep -i -q alpine /etc/issue; then \
apk add --no-cache ca-certificates bash tzdata musl-utils && \
apk info -vv | sort; \
elif grep -i -q ubuntu /etc/issue; then \
DEBIAN_FRONTEND=noninteractive && \
apt-get update && \
apt-get install -y ca-certificates curl tzdata && \
apt-get autoremove -y && \
rm -rf /var/lib/apt/lists/*; \
else \
echo 'ERROR: Unsupported base image' && /bin/false; \
fi
# Oracle Support for x86_64 only # glibc support for alpine x86_64 only
RUN if [ `arch` = "x86_64" ]; then \ RUN if grep -i -q alpine /etc/issue && [ `arch` = "x86_64" ]; then \
wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.35-r0/glibc-2.35-r0.apk \ wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.35-r0/glibc-2.35-r0.apk \
-O /tmp/glibc-2.35-r0.apk && \ -O /tmp/glibc-2.35-r0.apk && \
wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.35-r0/glibc-bin-2.35-r0.apk \ wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.35-r0/glibc-bin-2.35-r0.apk \
@@ -44,15 +72,22 @@ RUN if [ `arch` = "x86_64" ]; then \
rm -f /etc/ld.so.cache; \ rm -f /etc/ld.so.cache; \
fi fi
COPY --from=0 /tmp/grafana "$GF_PATHS_HOME" COPY --from=tgz-builder /tmp/grafana/conf ./conf
RUN if [ ! $(getent group "$GF_GID") ]; then \ RUN if [ ! $(getent group "$GF_GID") ]; then \
addgroup -S -g $GF_GID grafana; \ if grep -i -q alpine /etc/issue; then \
fi addgroup -S -g $GF_GID grafana; \
else \
RUN export GF_GID_NAME=$(getent group $GF_GID | cut -d':' -f1) && \ addgroup --system --gid $GF_GID grafana; \
fi; \
fi && \
GF_GID_NAME=$(getent group $GF_GID | cut -d':' -f1) && \
mkdir -p "$GF_PATHS_HOME/.aws" && \ mkdir -p "$GF_PATHS_HOME/.aws" && \
adduser -S -u $GF_UID -G "$GF_GID_NAME" grafana && \ if grep -i -q alpine /etc/issue; then \
adduser -S -u $GF_UID -G "$GF_GID_NAME" grafana; \
else \
adduser --system --uid $GF_UID --ingroup "$GF_GID_NAME" grafana; \
fi && \
mkdir -p "$GF_PATHS_PROVISIONING/datasources" \ mkdir -p "$GF_PATHS_PROVISIONING/datasources" \
"$GF_PATHS_PROVISIONING/dashboards" \ "$GF_PATHS_PROVISIONING/dashboards" \
"$GF_PATHS_PROVISIONING/notifiers" \ "$GF_PATHS_PROVISIONING/notifiers" \
@@ -62,11 +97,14 @@ RUN export GF_GID_NAME=$(getent group $GF_GID | cut -d':' -f1) && \
"$GF_PATHS_LOGS" \ "$GF_PATHS_LOGS" \
"$GF_PATHS_PLUGINS" \ "$GF_PATHS_PLUGINS" \
"$GF_PATHS_DATA" && \ "$GF_PATHS_DATA" && \
cp "$GF_PATHS_HOME/conf/sample.ini" "$GF_PATHS_CONFIG" && \ cp conf/sample.ini "$GF_PATHS_CONFIG" && \
cp "$GF_PATHS_HOME/conf/ldap.toml" /etc/grafana/ldap.toml && \ cp conf/ldap.toml /etc/grafana/ldap.toml && \
chown -R "grafana:$GF_GID_NAME" "$GF_PATHS_DATA" "$GF_PATHS_HOME/.aws" "$GF_PATHS_LOGS" "$GF_PATHS_PLUGINS" "$GF_PATHS_PROVISIONING" && \ chown -R "grafana:$GF_GID_NAME" "$GF_PATHS_DATA" "$GF_PATHS_HOME/.aws" "$GF_PATHS_LOGS" "$GF_PATHS_PLUGINS" "$GF_PATHS_PROVISIONING" && \
chmod -R 777 "$GF_PATHS_DATA" "$GF_PATHS_HOME/.aws" "$GF_PATHS_LOGS" "$GF_PATHS_PLUGINS" "$GF_PATHS_PROVISIONING" chmod -R 777 "$GF_PATHS_DATA" "$GF_PATHS_HOME/.aws" "$GF_PATHS_LOGS" "$GF_PATHS_PLUGINS" "$GF_PATHS_PROVISIONING"
COPY --from=tgz-builder /tmp/grafana/bin/grafana-server /tmp/grafana/bin/grafana-cli ./bin/
COPY --from=tgz-builder /tmp/grafana/public ./public
EXPOSE 3000 EXPOSE 3000
COPY ./run.sh /run.sh COPY ./run.sh /run.sh

12
packaging/docker/build-enterprise.sh
View File

@@ -2,11 +2,13 @@
set -e set -e
UBUNTU_BASE=0 UBUNTU_BASE=0
TAG_SUFFIX=""
while [ "$1" != "" ]; do while [ "$1" != "" ]; do
case "$1" in case "$1" in
"--ubuntu") "--ubuntu")
UBUNTU_BASE=1 UBUNTU_BASE=1
TAG_SUFFIX="-ubuntu"
echo "Ubuntu base image enabled" echo "Ubuntu base image enabled"
shift shift
;; ;;
@@ -28,20 +30,11 @@ else
_grafana_tag="${_raw_grafana_tag}" _grafana_tag="${_raw_grafana_tag}"
fi fi
if [ ${UBUNTU_BASE} = "0" ]; then
TAG_SUFFIX=""
DOCKERFILE="Dockerfile"
else
TAG_SUFFIX="-ubuntu"
DOCKERFILE="ubuntu.Dockerfile"
fi
echo "Building and deploying ${_docker_repo}:${_grafana_tag}${TAG_SUFFIX}" echo "Building and deploying ${_docker_repo}:${_grafana_tag}${TAG_SUFFIX}"
docker build \ docker build \
--tag "${_docker_repo}:${_grafana_tag}${TAG_SUFFIX}" \ --tag "${_docker_repo}:${_grafana_tag}${TAG_SUFFIX}" \
--no-cache=true \ --no-cache=true \
-f ${DOCKERFILE} \
. .
docker push "${_docker_repo}:${_grafana_tag}${TAG_SUFFIX}" docker push "${_docker_repo}:${_grafana_tag}${TAG_SUFFIX}"
@@ -56,4 +49,3 @@ if echo "${_raw_grafana_tag}" | grep -q "^main-" && [ ${UBUNTU_BASE} = "1" ]; th
docker tag "${_docker_repo}:${_grafana_tag}${TAG_SUFFIX}" "grafana/grafana-enterprise-dev:${_raw_grafana_tag}" docker tag "${_docker_repo}:${_grafana_tag}${TAG_SUFFIX}" "grafana/grafana-enterprise-dev:${_raw_grafana_tag}"
docker push "grafana/grafana-enterprise-dev:${_raw_grafana_tag}" docker push "grafana/grafana-enterprise-dev:${_raw_grafana_tag}"
fi fi

7
packaging/docker/build.sh
View File

@@ -28,7 +28,7 @@ done
_grafana_tag=${1:-} _grafana_tag=${1:-}
_docker_repo=${2:-grafana/grafana} _docker_repo=${2:-grafana/grafana}
# If the tag starts with v, treat this as a official release # If the tag starts with v, treat this as an official release
if echo "$_grafana_tag" | grep -q "^v"; then if echo "$_grafana_tag" | grep -q "^v"; then
_grafana_version=$(echo "${_grafana_tag}" | cut -d "v" -f 2) _grafana_version=$(echo "${_grafana_tag}" | cut -d "v" -f 2)
else else
@@ -59,15 +59,13 @@ docker_build () {
esac esac
if [ $UBUNTU_BASE = "0" ]; then if [ $UBUNTU_BASE = "0" ]; then
libc="-musl" libc="-musl"
dockerfile="Dockerfile"
base_image="${base_arch}alpine:3.15" base_image="${base_arch}alpine:3.15"
else else
libc="" libc=""
dockerfile="ubuntu.Dockerfile"
base_image="${base_arch}ubuntu:20.04" base_image="${base_arch}ubuntu:20.04"
fi fi
grafana_tgz="grafana-latest.linux-${arch}${libc}.tar.gz" grafana_tgz=${GRAFANA_TGZ:-"grafana-latest.linux-${arch}${libc}.tar.gz"}
tag="${_docker_repo}${repo_arch}:${_grafana_version}${TAG_SUFFIX}" tag="${_docker_repo}${repo_arch}:${_grafana_version}${TAG_SUFFIX}"
docker build \ docker build \
@@ -75,7 +73,6 @@ docker_build () {
--build-arg GRAFANA_TGZ=${grafana_tgz} \ --build-arg GRAFANA_TGZ=${grafana_tgz} \
--tag "${tag}" \ --tag "${tag}" \
--no-cache=true \ --no-cache=true \
-f "${dockerfile}" \
. .
} }

92
packaging/docker/custom/Dockerfile
View File

@@ -1,48 +1,44 @@
ARG GRAFANA_VERSION="latest" ARG GRAFANA_VERSION="latest"
FROM grafana/grafana:${GRAFANA_VERSION} FROM grafana/grafana:${GRAFANA_VERSION}
USER root USER root
ARG GF_INSTALL_IMAGE_RENDERER_PLUGIN="false" ARG GF_INSTALL_IMAGE_RENDERER_PLUGIN="false"
ARG GF_GID="0" ARG GF_GID="0"
ENV GF_PATHS_PLUGINS="/var/lib/grafana-plugins" ENV GF_PATHS_PLUGINS="/var/lib/grafana-plugins"
RUN mkdir -p "$GF_PATHS_PLUGINS" && \ RUN mkdir -p "$GF_PATHS_PLUGINS" && \
chown -R grafana:${GF_GID} "$GF_PATHS_PLUGINS" chown -R grafana:${GF_GID} "$GF_PATHS_PLUGINS" && \
if [ $GF_INSTALL_IMAGE_RENDERER_PLUGIN = "true" ]; then \
RUN if [ $GF_INSTALL_IMAGE_RENDERER_PLUGIN = "true" ]; then \ apk add --no-cache udev ttf-opensans chromium \
apk --no-cache upgrade && \ fi
apk add --no-cache udev ttf-opensans chromium && \
rm -rf /tmp/* && \ USER grafana
rm -rf /usr/share/grafana/tools/phantomjs; \
fi ENV GF_PLUGIN_RENDERING_CHROME_BIN="/usr/bin/chromium-browser"
USER grafana RUN if [ $GF_INSTALL_IMAGE_RENDERER_PLUGIN = "true" ]; then \
grafana-cli \
ENV GF_PLUGIN_RENDERING_CHROME_BIN="/usr/bin/chromium-browser" --pluginsDir "$GF_PATHS_PLUGINS" \
--pluginUrl https://github.com/grafana/grafana-image-renderer/releases/latest/download/plugin-linux-x64-glibc-no-chromium.zip \
RUN if [ $GF_INSTALL_IMAGE_RENDERER_PLUGIN = "true" ]; then \ plugins install grafana-image-renderer; \
grafana-cli \ fi
--pluginsDir "$GF_PATHS_PLUGINS" \
--pluginUrl https://github.com/grafana/grafana-image-renderer/releases/latest/download/plugin-linux-x64-glibc-no-chromium.zip \ ARG GF_INSTALL_PLUGINS=""
plugins install grafana-image-renderer; \
fi RUN if [ ! -z "${GF_INSTALL_PLUGINS}" ]; then \
OLDIFS=$IFS; \
ARG GF_INSTALL_PLUGINS="" IFS=','; \
for plugin in ${GF_INSTALL_PLUGINS}; do \
RUN if [ ! -z "${GF_INSTALL_PLUGINS}" ]; then \ IFS=$OLDIFS; \
OLDIFS=$IFS; \ if expr match "$plugin" '.*\;.*'; then \
IFS=','; \ pluginUrl=$(echo "$plugin" | cut -d';' -f 1); \
for plugin in ${GF_INSTALL_PLUGINS}; do \ pluginInstallFolder=$(echo "$plugin" | cut -d';' -f 2); \
IFS=$OLDIFS; \ grafana-cli --pluginUrl ${pluginUrl} --pluginsDir "${GF_PATHS_PLUGINS}" plugins install "${pluginInstallFolder}"; \
if expr match "$plugin" '.*\;.*'; then \ else \
pluginUrl=$(echo "$plugin" | cut -d';' -f 1); \ grafana-cli --pluginsDir "${GF_PATHS_PLUGINS}" plugins install ${plugin}; \
pluginInstallFolder=$(echo "$plugin" | cut -d';' -f 2); \ fi \
grafana-cli --pluginUrl ${pluginUrl} --pluginsDir "${GF_PATHS_PLUGINS}" plugins install "${pluginInstallFolder}"; \ done \
else \ fi
grafana-cli --pluginsDir "${GF_PATHS_PLUGINS}" plugins install ${plugin}; \
fi \
done \
fi

105
packaging/docker/custom/ubuntu.Dockerfile
View File

@@ -1,55 +1,50 @@
ARG GRAFANA_VERSION="latest" ARG GRAFANA_VERSION="latest"
FROM grafana/grafana:${GRAFANA_VERSION}-ubuntu FROM grafana/grafana:${GRAFANA_VERSION}-ubuntu
USER root USER root
# Set DEBIAN_FRONTEND=noninteractive in environment at build-time ARG GF_INSTALL_IMAGE_RENDERER_PLUGIN="false"
ARG DEBIAN_FRONTEND=noninteractive
ARG GF_GID="0"
ARG GF_INSTALL_IMAGE_RENDERER_PLUGIN="false" ENV GF_PATHS_PLUGINS="/var/lib/grafana-plugins"
ARG GF_GID="0" RUN mkdir -p "$GF_PATHS_PLUGINS" && \
ENV GF_PATHS_PLUGINS="/var/lib/grafana-plugins" chown -R grafana:${GF_GID} "$GF_PATHS_PLUGINS" && \
if [ $GF_INSTALL_IMAGE_RENDERER_PLUGIN = "true" ]; then \
RUN mkdir -p "$GF_PATHS_PLUGINS" && \ cd /tmp && \
chown -R grafana:${GF_GID} "$GF_PATHS_PLUGINS" curl -LO https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb && \
DEBIAN_FRONTEND=noninteractive && \
RUN if [ $GF_INSTALL_IMAGE_RENDERER_PLUGIN = "true" ]; then \ apt-get update && \
apt-get update && \ apt-get install -y ./google-chrome-stable_current_amd64.deb && \
apt-get upgrade -y && \ rm -rf /var/lib/apt/lists/* && \
apt-get install -y gdebi-core && \ rm ./google-chrome-stable_current_amd64.deb \
cd /tmp && \ fi
curl -LO https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb && \
gdebi --n google-chrome-stable_current_amd64.deb && \ USER grafana
apt-get autoremove -y && \
rm -rf /var/lib/apt/lists/*; \ ENV GF_PLUGIN_RENDERING_CHROME_BIN="/usr/bin/google-chrome"
fi
RUN if [ $GF_INSTALL_IMAGE_RENDERER_PLUGIN = "true" ]; then \
USER grafana grafana-cli \
--pluginsDir "$GF_PATHS_PLUGINS" \
ENV GF_PLUGIN_RENDERING_CHROME_BIN="/usr/bin/google-chrome" --pluginUrl https://github.com/grafana/grafana-image-renderer/releases/latest/download/plugin-linux-x64-glibc-no-chromium.zip \
plugins install grafana-image-renderer; \
RUN if [ $GF_INSTALL_IMAGE_RENDERER_PLUGIN = "true" ]; then \ fi
grafana-cli \
--pluginsDir "$GF_PATHS_PLUGINS" \ ARG GF_INSTALL_PLUGINS=""
--pluginUrl https://github.com/grafana/grafana-image-renderer/releases/latest/download/plugin-linux-x64-glibc-no-chromium.zip \
plugins install grafana-image-renderer; \ RUN if [ ! -z "${GF_INSTALL_PLUGINS}" ]; then \
fi OLDIFS=$IFS; \
IFS=','; \
ARG GF_INSTALL_PLUGINS="" for plugin in ${GF_INSTALL_PLUGINS}; do \
IFS=$OLDIFS; \
RUN if [ ! -z "${GF_INSTALL_PLUGINS}" ]; then \ if expr match "$plugin" '.*\;.*'; then \
OLDIFS=$IFS; \ pluginUrl=$(echo "$plugin" | cut -d';' -f 1); \
IFS=','; \ pluginInstallFolder=$(echo "$plugin" | cut -d';' -f 2); \
for plugin in ${GF_INSTALL_PLUGINS}; do \ grafana-cli --pluginUrl ${pluginUrl} --pluginsDir "${GF_PATHS_PLUGINS}" plugins install "${pluginInstallFolder}"; \
IFS=$OLDIFS; \ else \
if expr match "$plugin" '.*\;.*'; then \ grafana-cli --pluginsDir "${GF_PATHS_PLUGINS}" plugins install ${plugin}; \
pluginUrl=$(echo "$plugin" | cut -d';' -f 1); \ fi \
pluginInstallFolder=$(echo "$plugin" | cut -d';' -f 2); \ done \
grafana-cli --pluginUrl ${pluginUrl} --pluginsDir "${GF_PATHS_PLUGINS}" plugins install "${pluginInstallFolder}"; \ fi
else \
grafana-cli --pluginsDir "${GF_PATHS_PLUGINS}" plugins install ${plugin}; \
fi \
done \
fi

30
packaging/docker/push_to_docker_hub.sh
View File

@@ -24,18 +24,18 @@ _docker_repo=${2:-grafana/grafana}
# If the tag starts with v, treat this as an official release # If the tag starts with v, treat this as an official release
if echo "$_grafana_tag" | grep -q "^v"; then if echo "$_grafana_tag" | grep -q "^v"; then
_grafana_version=$(echo "${_grafana_tag}" | cut -d "v" -f 2) _grafana_version=$(echo "${_grafana_tag}" | cut -d "v" -f 2)
else else
_grafana_version=$_grafana_tag _grafana_version=$_grafana_tag
fi fi
export DOCKER_CLI_EXPERIMENTAL=enabled
echo "pushing ${_docker_repo}:${_grafana_version}${TAG_SUFFIX}" echo "pushing ${_docker_repo}:${_grafana_version}${TAG_SUFFIX}"
export DOCKER_CLI_EXPERIMENTAL=enabled
docker_push_all () { docker_push_all () {
repo=$1 repo=$1
tag=$2 tag=$2
# Push each image individually # Push each image individually
docker push "${repo}:${tag}${TAG_SUFFIX}" docker push "${repo}:${tag}${TAG_SUFFIX}"
@@ -52,18 +52,18 @@ docker_push_all () {
} }
if echo "$_grafana_tag" | grep -q "^v" && echo "$_grafana_tag" | grep -vq "beta"; then if echo "$_grafana_tag" | grep -q "^v" && echo "$_grafana_tag" | grep -vq "beta"; then
echo "pushing ${_docker_repo}:latest${TAG_SUFFIX}" echo "pushing ${_docker_repo}:latest${TAG_SUFFIX}"
docker_push_all "${_docker_repo}" "latest" docker_push_all "${_docker_repo}" "latest"
docker_push_all "${_docker_repo}" "${_grafana_version}" docker_push_all "${_docker_repo}" "${_grafana_version}"
# Push to the grafana-dev repository with the expected tag # Push to the grafana-dev repository with the expected tag
# for running the end to end tests successfully # for running the end to end tests successfully
docker push "grafana/grafana-dev:${_grafana_tag}${TAG_SUFFIX}" docker push "grafana/grafana-dev:${_grafana_tag}${TAG_SUFFIX}"
elif echo "$_grafana_tag" | grep -q "^v" && echo "$_grafana_tag" | grep -q "beta"; then elif echo "$_grafana_tag" | grep -q "^v" && echo "$_grafana_tag" | grep -q "beta"; then
docker_push_all "${_docker_repo}" "${_grafana_version}" docker_push_all "${_docker_repo}" "${_grafana_version}"
# Push to the grafana-dev repository with the expected tag # Push to the grafana-dev repository with the expected tag
# for running the end to end tests successfully # for running the end to end tests successfully
docker push "grafana/grafana-dev:${_grafana_tag}${TAG_SUFFIX}" docker push "grafana/grafana-dev:${_grafana_tag}${TAG_SUFFIX}"
elif echo "$_grafana_tag" | grep -q "main"; then elif echo "$_grafana_tag" | grep -q "main"; then
docker_push_all "${_docker_repo}" "main" docker_push_all "${_docker_repo}" "main"
docker push "grafana/grafana-dev:${_grafana_version}${TAG_SUFFIX}" docker push "grafana/grafana-dev:${_grafana_version}${TAG_SUFFIX}"
fi fi

60
packaging/docker/ubuntu.Dockerfile
View File

@@ -1,60 +0,0 @@
ARG BASE_IMAGE=ubuntu:20.04
FROM ${BASE_IMAGE} AS grafana-builder
ARG GRAFANA_TGZ="grafana-latest.linux-x64.tar.gz"
COPY ${GRAFANA_TGZ} /tmp/grafana.tar.gz
RUN mkdir /tmp/grafana && tar xzf /tmp/grafana.tar.gz --strip-components=1 -C /tmp/grafana
FROM ${BASE_IMAGE}
EXPOSE 3000
# Set DEBIAN_FRONTEND=noninteractive in environment at build-time
ARG DEBIAN_FRONTEND=noninteractive
ARG GF_UID="472"
ARG GF_GID="0"
ENV PATH=/usr/share/grafana/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin \
GF_PATHS_CONFIG="/etc/grafana/grafana.ini" \
GF_PATHS_DATA="/var/lib/grafana" \
GF_PATHS_HOME="/usr/share/grafana" \
GF_PATHS_LOGS="/var/log/grafana" \
GF_PATHS_PLUGINS="/var/lib/grafana/plugins" \
GF_PATHS_PROVISIONING="/etc/grafana/provisioning"
WORKDIR $GF_PATHS_HOME
# Install dependencies
# We need curl in the image
RUN apt-get update && apt-get install -y ca-certificates curl tzdata && \
apt-get autoremove -y && rm -rf /var/lib/apt/lists/*;
COPY --from=grafana-builder /tmp/grafana "$GF_PATHS_HOME"
RUN if [ ! $(getent group "$GF_GID") ]; then \
addgroup --system --gid $GF_GID grafana; \
fi
RUN export GF_GID_NAME=$(getent group $GF_GID | cut -d':' -f1) && \
mkdir -p "$GF_PATHS_HOME/.aws" && \
adduser --system --uid $GF_UID --ingroup "$GF_GID_NAME" grafana && \
mkdir -p "$GF_PATHS_PROVISIONING/datasources" \
"$GF_PATHS_PROVISIONING/dashboards" \
"$GF_PATHS_PROVISIONING/notifiers" \
"$GF_PATHS_PROVISIONING/plugins" \
"$GF_PATHS_PROVISIONING/access-control" \
"$GF_PATHS_PROVISIONING/alerting" \
"$GF_PATHS_LOGS" \
"$GF_PATHS_PLUGINS" \
"$GF_PATHS_DATA" && \
cp "$GF_PATHS_HOME/conf/sample.ini" "$GF_PATHS_CONFIG" && \
cp "$GF_PATHS_HOME/conf/ldap.toml" /etc/grafana/ldap.toml && \
chown -R "grafana:$GF_GID_NAME" "$GF_PATHS_DATA" "$GF_PATHS_HOME/.aws" "$GF_PATHS_LOGS" "$GF_PATHS_PLUGINS" "$GF_PATHS_PROVISIONING" && \
chmod -R 777 "$GF_PATHS_DATA" "$GF_PATHS_HOME/.aws" "$GF_PATHS_LOGS" "$GF_PATHS_PLUGINS" "$GF_PATHS_PROVISIONING"
COPY ./run.sh /run.sh
USER "$GF_UID"
ENTRYPOINT [ "/run.sh" ]

4
pkg/build/docker/build.go
View File

@@ -70,12 +70,10 @@ func BuildImage(version string, arch config.Architecture, grafanaDir string, use
} }
libc := "-musl" libc := "-musl"
dockerfile := "Dockerfile"
baseImage := fmt.Sprintf("%salpine:3.15", baseArch) baseImage := fmt.Sprintf("%salpine:3.15", baseArch)
tagSuffix := "" tagSuffix := ""
if useUbuntu { if useUbuntu {
libc = "" libc = ""
dockerfile = "ubuntu.Dockerfile"
baseImage = fmt.Sprintf("%subuntu:20.04", baseArch) baseImage = fmt.Sprintf("%subuntu:20.04", baseArch)
tagSuffix = "-ubuntu" tagSuffix = "-ubuntu"
} }
@@ -120,7 +118,7 @@ func BuildImage(version string, arch config.Architecture, grafanaDir string, use
args := []string{ args := []string{
"build", "--build-arg", fmt.Sprintf("BASE_IMAGE=%s", baseImage), "build", "--build-arg", fmt.Sprintf("BASE_IMAGE=%s", baseImage),
"--build-arg", fmt.Sprintf("GRAFANA_TGZ=%s", archive), "--tag", tag, "--no-cache", "--build-arg", fmt.Sprintf("GRAFANA_TGZ=%s", archive), "--tag", tag, "--no-cache",
"-f", dockerfile, ".", ".",
} }
log.Printf("Running Docker: docker %s", strings.Join(args, " ")) log.Printf("Running Docker: docker %s", strings.Join(args, " "))