[MM-56058] Multi arch builds support (#20)

* Multi arch builds support

* Detect M1 hosts

Makefile

@@ -31,8 +31,17 @@ CONFIG_APP_CODE         += ./cmd/transcriber
 ifneq (, $(shell which go))
 ARCH                    ?= $(shell go version | awk '{print substr($$4,index($$4,"/")+1)}')
 endif
+# Target OS will always be linux.
+OS                      := linux
 # Fallback to amd64 if ARCH is still unset.
 ARCH                    ?= amd64
+# We need to detect M1 host platforms.
+IS_M1                   := false
+ifeq ($(shell uname -s),Darwin)
+ifeq ($(shell uname -p),arm)
+IS_M1 = true
+endif
+endif
 
 ## CGO dependencies
 # Whisper.cpp
@@ -44,31 +53,39 @@ OPUS_VERSION ?= "1.4"
 OPUS_SHA ?= "c9b32b4253be5ae63d1ff16eea06b94b5f0f2951b7a02aceef58e3a3ce49c51f"
 # ONNX Runtime
 ONNX_VERSION ?= "1.16.2"
-ONNX_SHA ?= "70c769771ad4b6d63b87ca1f62d3f11e998ea0b9d738d6bbdd6a5e6d8c1deb31"
 
 ## Docker Variables
 # Docker executable
 DOCKER                  := $(shell which docker)
 # Dockerfile's location
 DOCKER_FILE             += ./build/Dockerfile
 # Docker options to inherit for all docker run commands
-DOCKER_OPTS             += --rm -u $$(id -u):$$(id -g) --platform "linux/amd64"
+DOCKER_OPTS             += --rm -u $$(id -u):$$(id -g) --platform "linux/${ARCH}"
 # Registry to upload images
 DOCKER_REGISTRY         ?= docker.io
 DOCKER_REGISTRY_REPO    ?= mattermost/${APP_NAME}-daily
+DOCKER_TAG              ?= ${APP_NAME}:${APP_VERSION}
 # Registry credentials
 DOCKER_USER             ?= user
 DOCKER_PASSWORD         ?= password
 ## Docker Images
-DOCKER_IMAGE_GO         += "golang:${GO_VERSION}@sha256:337543447173c2238c78d4851456760dcc57c1dfa8c3bcd94cbee8b0f7b32ad0"
+DOCKER_IMAGE_GO         += "golang:${GO_VERSION}"
 DOCKER_IMAGE_GOLINT     += "golangci/golangci-lint:v1.54.2@sha256:abe731fe6bb335a30eab303a41dd5c2b630bb174372a4da08e3d42eab5324127"
-DOCKER_IMAGE_DOCKERLINT += "hadolint/hadolint:v2.9.2@sha256:d355bd7df747a0f124f3b5e7b21e9dafd0cb19732a276f901f0fdee243ec1f3b"
+DOCKER_IMAGE_DOCKERLINT += "hadolint/hadolint:v2.12.0@sha256:9259e253a4e299b50c92006149dd3a171c7ea3c5bd36f060022b5d2c1ff0fbbe"
 DOCKER_IMAGE_COSIGN     += "bitnami/cosign:1.8.0@sha256:8c2c61c546258fffff18b47bb82a65af6142007306b737129a7bd5429d53629a"
 DOCKER_IMAGE_GH_CLI     += "ghcr.io/supportpal/github-gh-cli:2.31.0@sha256:71371e36e62bd24ddd42d9e4c720a7e9954cb599475e24d1407af7190e2a5685"
 
-DOCKER_IMAGE_RUNNER     := "debian:bookworm-slim@sha256:5bbfcb9f36a506f9c9c2fb53205f15f6e9d1f0e032939378ddc049a2d26d651e"
-ifeq ($(ARCH),arm64)
-	DOCKER_IMAGE_RUNNER="arm64v8/debian:bookworm-slim@sha256:593234c0624826b26d7f7f807456dfc615c4d0f748a3ac410fbaf31a0b1d32ff"
+# When running locally we default to the current architecture.
+DOCKER_BUILD_PLATFORMS   := "${OS}/${ARCH}"
+DOCKER_BUILD_OUTPUT_TYPE := "docker"
+DOCKER_BUILDER           := "multiarch"
+DOCKER_BUILDER_MISSING   := $(shell docker buildx inspect ${DOCKER_BUILDER} > /dev/null 2>&1; echo $$?)
+
+# When running on CI we want to use our official release targets.
+ifeq ($(CI),true)
+DOCKER_BUILD_PLATFORMS   := "linux/amd64,linux/arm64"
+DOCKER_BUILD_OUTPUT_TYPE := "registry"
+DOCKER_TAG               :=  ${DOCKER_REGISTRY}/${DOCKER_REGISTRY_REPO}:${APP_VERSION}
 endif
 
 ## Cosign Variables
@@ -90,7 +107,7 @@ GO_LDFLAGS                   += -X "github.com/mattermost/${APP_NAME}/service.bu
 GO_LDFLAGS                   += -X "github.com/mattermost/${APP_NAME}/service.buildDate=$(BUILD_DATE)"
 GO_LDFLAGS                   += -X "github.com/mattermost/${APP_NAME}/service.goVersion=$(GO_VERSION)"
 # Architectures to build for
-GO_BUILD_PLATFORMS           ?= linux-amd64
+GO_BUILD_PLATFORMS           ?= "linux-${ARCH}"
 GO_BUILD_PLATFORMS_ARTIFACTS = $(foreach cmd,$(addprefix go-build/,${APP_NAME}),$(addprefix $(cmd)-,$(GO_BUILD_PLATFORMS)))
 # Build options
 GO_BUILD_OPTS                += -mod=readonly -trimpath -buildmode=pie
@@ -152,7 +169,7 @@ build: go-build-docker ## to build
 release: build github-release ## to build and release artifacts
 
 .PHONY: package
-package: docker-login docker-build docker-push ## to build, package and push the artifact to a container registry
+package: docker-login docker-build ## to build, package and push the artifact to a container registry
 
 .PHONY: sign
 sign: docker-sign docker-verify ## to sign the artifact and perform verification
@@ -163,37 +180,46 @@ lint: go-lint ## to lint
 .PHONY: test
 test: go-test ## to test
 
-.PHONY: docker-build
 docker-build: ## to build the docker image
-	@$(INFO) Performing Docker build ${APP_NAME}:${APP_VERSION} for ${ARCH}
-	$(AT)$(DOCKER) build \
-	--build-arg GO_IMAGE=${DOCKER_IMAGE_GO} \
-	--build-arg ARCH=${ARCH} \
-	--build-arg RUNNER_IMAGE=${DOCKER_IMAGE_RUNNER} \
+	@$(INFO) Performing Docker build ${APP_NAME}:${APP_VERSION} for ${DOCKER_BUILD_PLATFORMS}
+ifeq ($(DOCKER_BUILDER_MISSING),1)
+ifeq ($(CI),true)
+	@$(INFO) Creating ${DOCKER_BUILDER} builder
+	$(AT)$(DOCKER) buildx create --name ${DOCKER_BUILDER} --use
+endif
+endif
+	$(AT)$(DOCKER) buildx build \
+	--platform ${DOCKER_BUILD_PLATFORMS} \
+	--output=type=${DOCKER_BUILD_OUTPUT_TYPE} \
+	--build-arg GO_VERSION=${GO_VERSION} \
 	--build-arg OPUS_VERSION=${OPUS_VERSION} \
 	--build-arg OPUS_SHA=${OPUS_SHA} \
 	--build-arg WHISPER_VERSION=${WHISPER_VERSION} \
 	--build-arg WHISPER_SHA=${WHISPER_SHA} \
 	--build-arg WHISPER_MODELS=${WHISPER_MODELS} \
 	--build-arg ONNX_VERSION=${ONNX_VERSION} \
-	--build-arg ONNX_SHA=${ONNX_SHA} \
+	--build-arg IS_M1=${IS_M1} \
 	-f ${DOCKER_FILE} . \
-	-t ${APP_NAME}:${APP_VERSION} || ${FAIL}
-	@$(OK) Performing Docker build ${APP_NAME}:${APP_VERSION}
-
-.PHONY: docker-push
-docker-push: ## to push the docker image
-	@$(INFO) Pushing to registry...
-	$(AT)$(DOCKER) tag ${APP_NAME}:${APP_VERSION} $(DOCKER_REGISTRY)/${DOCKER_REGISTRY_REPO}:${APP_VERSION} || ${FAIL}
-	$(AT)$(DOCKER) push $(DOCKER_REGISTRY)/${DOCKER_REGISTRY_REPO}:${APP_VERSION} || ${FAIL}
-# if we are on a latest semver APP_VERSION tag, also push latest
+	-t ${DOCKER_TAG} || ${FAIL}
+	@$(OK) Performing Docker build ${APP_NAME}:${APP_VERSION} for ${DOCKER_BUILD_PLATFORMS}
+ifeq ($(CI),true)
 ifneq ($(shell echo $(APP_VERSION) | egrep '^v([0-9]+\.){0,2}(\*|[0-9]+)'),)
-  ifeq ($(shell git tag -l --sort=v:refname | tail -n1),$(APP_VERSION))
-	$(AT)$(DOCKER) tag ${APP_NAME}:${APP_VERSION} $(DOCKER_REGISTRY)/${DOCKER_REGISTRY_REPO}:latest || ${FAIL}
-	$(AT)$(DOCKER) push $(DOCKER_REGISTRY)/${DOCKER_REGISTRY_REPO}:latest || ${FAIL}
-  endif
+ifeq ($(shell git tag -l --sort=v:refname | tail -n1),$(APP_VERSION))
+	$(AT)$(DOCKER) buildx build \
+	--platform ${DOCKER_BUILD_PLATFORMS} \
+	--output=type=${DOCKER_BUILD_OUTPUT_TYPE} \
+	--build-arg GO_VERSION=${GO_VERSION} \
+	--build-arg OPUS_VERSION=${OPUS_VERSION} \
+	--build-arg OPUS_SHA=${OPUS_SHA} \
+	--build-arg WHISPER_VERSION=${WHISPER_VERSION} \
+	--build-arg WHISPER_SHA=${WHISPER_SHA} \
+	--build-arg WHISPER_MODELS=${WHISPER_MODELS} \
+	--build-arg ONNX_VERSION=${ONNX_VERSION} \
+	-f ${DOCKER_FILE} . \
+	-t ${DOCKER_REGISTRY}/${DOCKER_REGISTRY_REPO}:latest || ${FAIL}
+endif
+endif
 endif
-	@$(OK) Pushing to registry $(DOCKER_REGISTRY)/${DOCKER_REGISTRY_REPO}:${APP_VERSION}
 
 .PHONY: docker-sign
 docker-sign: ## to sign the docker image
@@ -292,6 +318,7 @@ go-build/%:
 	export GOARCH="$${platform#*-}"; \
 	echo export GOOS=$${GOOS}; \
 	echo export GOARCH=$${GOARCH}; \
+	CGO_ENABLED=1 \
 	$(GO) build ${GO_BUILD_OPTS} \
 	-ldflags '${GO_LDFLAGS}' \
 	-o ${GO_OUT_BIN_DIR}/$* \
@@ -305,7 +332,7 @@ go-build-docker: # to build binaries under a controlled docker dedicated go cont
 	-v $(PWD):/app -w /app \
 	-e GOCACHE="/tmp" \
 	$(DOCKER_IMAGE_GO) \
-	/bin/bash ./build/build.sh ${OPUS_VERSION} ${OPUS_SHA} ${WHISPER_VERSION} ${WHISPER_SHA} ${WHISPER_MODELS} ${ONNX_VERSION} ${ONNX_SHA} || ${FAIL}
+	/bin/bash ./build/build.sh ${OPUS_VERSION} ${OPUS_SHA} ${WHISPER_VERSION} ${WHISPER_SHA} ${WHISPER_MODELS} ${ONNX_VERSION} ${ARCH} || ${FAIL}
 	@$(OK) go build docker
 
 .PHONY: go-run
@@ -322,7 +349,7 @@ go-test: ## to run tests
 	-v /var/run/docker.sock:/var/run/docker.sock \
 	-e GOCACHE="/tmp" \
 	$(DOCKER_IMAGE_GO) \
-	/bin/sh ./build/run_tests.sh "${GO_TEST_OPTS}" "${OPUS_VERSION}" "${OPUS_SHA}" "${WHISPER_VERSION}" "${WHISPER_SHA}" "${ONNX_VERSION}" "${ONNX_SHA}" || ${FAIL}
+	/bin/sh ./build/run_tests.sh "${GO_TEST_OPTS}" "${OPUS_VERSION}" "${OPUS_SHA}" "${WHISPER_VERSION}" "${WHISPER_SHA}" "${ONNX_VERSION}" "${ARCH}" || ${FAIL}
 	@$(OK) testing
 
 .PHONY: go-mod-check
@@ -349,7 +376,7 @@ go-lint: ## to lint go code
 	-e GOCACHE="/tmp" \
 	-e GOLANGCI_LINT_CACHE="/tmp" \
 	${DOCKER_IMAGE_GOLINT} \
-	/bin/sh ./build/lint.sh "${OPUS_VERSION}" "${OPUS_SHA}" "${WHISPER_VERSION}" "${WHISPER_SHA}" "${ONNX_VERSION}" "${ONNX_SHA}" || ${FAIL}
+	/bin/sh ./build/lint.sh "${OPUS_VERSION}" "${OPUS_SHA}" "${WHISPER_VERSION}" "${WHISPER_SHA}" "${ONNX_VERSION}" "${ARCH}" || ${FAIL}
 	@$(OK) App linting
 
 .PHONY: go-fmt

build/Dockerfile

@@ -1,11 +1,8 @@
 # This dockerfile is used to build Mattermost calls-transcriber
 # A multi stage build, with golang used as a builder
 # and debian:bookworm-slim as runner
-ARG ARCH
-ARG GO_IMAGE
-ARG RUNNER_IMAGE
-
-FROM ${RUNNER_IMAGE:?} as base
+ARG GO_VERSION
+FROM --platform=$TARGETPLATFORM debian:bookworm-20240211-slim as base
 
 # Setup system dependencies
 WORKDIR /workdir
@@ -20,35 +17,37 @@ RUN apt-get update && \
 # Create unprivileged user to run the recorder process
 RUN groupadd -r calls && useradd -mr -g calls calls
 
-FROM ${GO_IMAGE:?} as builder
-ARG ARCH
+ARG GO_VERSION
+FROM --platform=$TARGETPLATFORM golang:${GO_VERSION} as builder
+ARG TARGETOS
+ARG TARGETARCH
+ARG GO_BUILD_PLATFORMS=${TARGETOS}-${TARGETARCH}
 ARG OPUS_VERSION
 ARG OPUS_SHA
 ARG WHISPER_VERSION
 ARG WHISPER_SHA
 ARG WHISPER_MODELS
 ARG ONNX_VERSION
-ARG ONNX_SHA
 ARG DEBIAN_FRONTEND=noninteractive
-#GO_BUILD_PLATFORMS holds the platforms that we will build the docker image against
-ARG GO_BUILD_PLATFORMS=linux-${ARCH:?}
+ARG IS_M1
 
 # Setup directories structure and compile
 # We first copy just the build directory so that we can properly cache dependencies which can take a while to download.
 COPY ./build /src/build
 WORKDIR /src
-RUN /bin/bash ./build/prepare_deps.sh ${OPUS_VERSION} ${OPUS_SHA} ${WHISPER_VERSION} ${WHISPER_SHA} "${WHISPER_MODELS}" ${ONNX_VERSION} ${ONNX_SHA}
+RUN /bin/bash ./build/prepare_deps.sh ${OPUS_VERSION} ${OPUS_SHA} ${WHISPER_VERSION} ${WHISPER_SHA} "${WHISPER_MODELS}" ${ONNX_VERSION} ${TARGETARCH}
 
 COPY . /src
-RUN /bin/bash ./build/build.sh ${OPUS_VERSION} ${OPUS_SHA} ${WHISPER_VERSION} ${WHISPER_SHA} "${WHISPER_MODELS}" ${ONNX_VERSION} ${ONNX_SHA}
+RUN /bin/bash ./build/build.sh ${OPUS_VERSION} ${OPUS_SHA} ${WHISPER_VERSION} ${WHISPER_SHA} "${WHISPER_MODELS}" ${ONNX_VERSION} ${TARGETARCH}
 
 FROM base AS runner
-ARG ARCH
+ARG TARGETOS
+ARG TARGETARCH
 ARG WHISPER_VERSION
 ARG ONNX_VERSION
-COPY --from=builder /src/dist/calls-transcriber-linux-${ARCH:?} /opt/calls-transcriber/bin/calls-transcriber
+COPY --from=builder /src/dist/calls-transcriber-${TARGETOS}-${TARGETARCH} /opt/calls-transcriber/bin/calls-transcriber
 COPY --from=builder /tmp/whisper.cpp-${WHISPER_VERSION}/models /models
-COPY --from=builder /tmp/onnxruntime-linux-x64-${ONNX_VERSION}/lib/* /usr/lib/
+COPY --from=builder /tmp/onnxruntime-linux-${ONNX_VERSION}/lib/* /usr/lib/
 COPY --from=builder /src/build/models/silero_vad.onnx /models
 COPY --from=builder /src/build/entrypoint.sh .
 RUN ldconfig

build/build.sh

@@ -7,19 +7,19 @@ WHISPER_VERSION=$3
 WHISPER_SHA=$4
 MODELS=$5
 ONNX_VERSION=$6
-ONNX_SHA=$7
+TARGET_ARCH=$7
 
 OPUS_INCLUDE_PATH="/tmp/opus-${OPUS_VERSION}/include"
 WHISPER_INCLUDE_PATH="/tmp/whisper.cpp-${WHISPER_VERSION}"
 OPUS_LIBRARY_PATH="/tmp/opus-${OPUS_VERSION}/.libs"
 WHISPER_LIBRARY_PATH=${WHISPER_INCLUDE_PATH}
-ONNX_INCLUDE_PATH="/tmp/onnxruntime-linux-x64-${ONNX_VERSION}/include"
-ONNX_LIBRARY_PATH="/tmp/onnxruntime-linux-x64-${ONNX_VERSION}/lib"
+ONNX_INCLUDE_PATH="/tmp/onnxruntime-linux-${ONNX_VERSION}/include"
+ONNX_LIBRARY_PATH="/tmp/onnxruntime-linux-${ONNX_VERSION}/lib"
 
 # Only fetch dependencies if needed (e.g. not already cached by Docker).
 if [ ! -d "$OPUS_INCLUDE_PATH" ]; then
 	echo "Missing dependencies, downloading."
-	bash ./build/prepare_deps.sh ${OPUS_VERSION} ${OPUS_SHA} ${WHISPER_VERSION} ${WHISPER_SHA} "${MODELS}" ${ONNX_VERSION} ${ONNX_SHA}
+	bash ./build/prepare_deps.sh ${OPUS_VERSION} ${OPUS_SHA} ${WHISPER_VERSION} ${WHISPER_SHA} "${MODELS}" ${ONNX_VERSION} ${TARGET_ARCH}
 fi
 
 C_INCLUDE_PATH="${OPUS_INCLUDE_PATH}:${WHISPER_INCLUDE_PATH}:${ONNX_INCLUDE_PATH}" \

build/lint.sh

@@ -6,16 +6,16 @@ OPUS_SHA=$2
 WHISPER_VERSION=$3
 WHISPER_SHA=$4
 ONNX_VERSION=$5
-ONNX_SHA=$6
+TARGET_ARCH=$6
 
 OPUS_INCLUDE_PATH="/tmp/opus-${OPUS_VERSION}/include"
 WHISPER_INCLUDE_PATH="/tmp/whisper.cpp-${WHISPER_VERSION}"
 OPUS_LIBRARY_PATH="/tmp/opus-${OPUS_VERSION}/.libs"
 WHISPER_LIBRARY_PATH=${WHISPER_INCLUDE_PATH}
-ONNX_INCLUDE_PATH="/tmp/onnxruntime-linux-x64-${ONNX_VERSION}/include"
-ONNX_LIBRARY_PATH="/tmp/onnxruntime-linux-x64-${ONNX_VERSION}/lib"
+ONNX_INCLUDE_PATH="/tmp/onnxruntime-linux-${ONNX_VERSION}/include"
+ONNX_LIBRARY_PATH="/tmp/onnxruntime-linux-${ONNX_VERSION}/lib"
 
-bash ./build/prepare_deps.sh ${OPUS_VERSION} ${OPUS_SHA} ${WHISPER_VERSION} ${WHISPER_SHA} "" ${ONNX_VERSION} ${ONNX_SHA} && \
+bash ./build/prepare_deps.sh ${OPUS_VERSION} ${OPUS_SHA} ${WHISPER_VERSION} ${WHISPER_SHA} "" ${ONNX_VERSION} ${TARGET_ARCH} && \
 C_INCLUDE_PATH="${OPUS_INCLUDE_PATH}:${WHISPER_INCLUDE_PATH}:${ONNX_INCLUDE_PATH}" \
 LIBRARY_PATH="${OPUS_LIBRARY_PATH}:${WHISPER_LIBRARY_PATH}:${ONNX_LIBRARY_PATH}" \
 LD_RUN_PATH="${ONNX_LIBRARY_PATH}" \

build/prepare_deps.sh

@@ -7,23 +7,36 @@ WHISPER_VERSION=$3
 WHISPER_SHA=$4
 MODELS=$5
 ONNX_VERSION=$6
-ONNX_SHA=$7
+TARGET_ARCH=$7
+ONNX_ARCH=x64
+ONNX_SHA=70c769771ad4b6d63b87ca1f62d3f11e998ea0b9d738d6bbdd6a5e6d8c1deb31
+if [ "$TARGET_ARCH" == "arm64" ]; then
+	ONNX_ARCH=aarch64
+	ONNX_SHA=4c1a21bd9c3acc17d4176a09b89602954f511a97d489be0cfdf356ebd789c409
+fi
+
+UNAME_M=$(uname -m)
+if [ "$IS_M1" == "true" ]; then
+	echo "Overriding UNAME_M on detected M1 host";
+	UNAME_M="arm64"
+fi
 
 cd /tmp && \
 wget https://downloads.xiph.org/releases/opus/opus-${OPUS_VERSION}.tar.gz && \
 echo "${OPUS_SHA} opus-${OPUS_VERSION}.tar.gz" | sha256sum --check && \
 tar xf opus-${OPUS_VERSION}.tar.gz && \
 cd opus-${OPUS_VERSION} && \
 ./configure && \
-make && \
+make -j4 && \
 cd /tmp && \
 wget https://github.com/ggerganov/whisper.cpp/archive/refs/tags/v${WHISPER_VERSION}.tar.gz && \
 echo "${WHISPER_SHA} v${WHISPER_VERSION}.tar.gz" | sha256sum --check && \
 tar xf v${WHISPER_VERSION}.tar.gz && \
 cd whisper.cpp-${WHISPER_VERSION} && \
 for model in ${MODELS}; do ./models/download-ggml-model.sh "${model}"; done && \
-make libwhisper.a && \
+make -j4 libwhisper.a UNAME_M=${UNAME_M} && \
 cd /tmp && \
-wget https://github.com/microsoft/onnxruntime/releases/download/v${ONNX_VERSION}/onnxruntime-linux-x64-${ONNX_VERSION}.tgz && \
-echo "${ONNX_SHA} onnxruntime-linux-x64-${ONNX_VERSION}.tgz" | sha256sum --check && \
-tar xf onnxruntime-linux-x64-${ONNX_VERSION}.tgz
+wget https://github.com/microsoft/onnxruntime/releases/download/v${ONNX_VERSION}/onnxruntime-linux-${ONNX_ARCH}-${ONNX_VERSION}.tgz && \
+echo "${ONNX_SHA} onnxruntime-linux-${ONNX_ARCH}-${ONNX_VERSION}.tgz" | sha256sum --check && \
+tar xf onnxruntime-linux-${ONNX_ARCH}-${ONNX_VERSION}.tgz && \
+mv onnxruntime-linux-${ONNX_ARCH}-${ONNX_VERSION} onnxruntime-linux-${ONNX_VERSION}

build/run_tests.sh

@@ -7,16 +7,16 @@ OPUS_SHA=$3
 WHISPER_VERSION=$4
 WHISPER_SHA=$5
 ONNX_VERSION=$6
-ONNX_SHA=$7
+TARGET_ARCH=$7
 
 OPUS_INCLUDE_PATH="/tmp/opus-${OPUS_VERSION}/include"
 WHISPER_INCLUDE_PATH="/tmp/whisper.cpp-${WHISPER_VERSION}"
 OPUS_LIBRARY_PATH="/tmp/opus-${OPUS_VERSION}/.libs"
 WHISPER_LIBRARY_PATH=${WHISPER_INCLUDE_PATH}
-ONNX_INCLUDE_PATH="/tmp/onnxruntime-linux-x64-${ONNX_VERSION}/include"
-ONNX_LIBRARY_PATH="/tmp/onnxruntime-linux-x64-${ONNX_VERSION}/lib"
+ONNX_INCLUDE_PATH="/tmp/onnxruntime-linux-${ONNX_VERSION}/include"
+ONNX_LIBRARY_PATH="/tmp/onnxruntime-linux-${ONNX_VERSION}/lib"
 
-bash ./build/prepare_deps.sh ${OPUS_VERSION} ${OPUS_SHA} ${WHISPER_VERSION} ${WHISPER_SHA} "tiny" ${ONNX_VERSION} ${ONNX_SHA} && \
+bash ./build/prepare_deps.sh ${OPUS_VERSION} ${OPUS_SHA} ${WHISPER_VERSION} ${WHISPER_SHA} "tiny" ${ONNX_VERSION} ${TARGET_ARCH} && \
 mv /tmp/whisper.cpp-${WHISPER_VERSION}/models/ggml-tiny.bin /app/build/models && \
 MODELS_DIR=/app/build/models \
 C_INCLUDE_PATH="${OPUS_INCLUDE_PATH}:${WHISPER_INCLUDE_PATH}:${ONNX_INCLUDE_PATH}" \