forked from kubernetes-sigs/gcp-filestore-csi-driver
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Makefile
184 lines (160 loc) · 8.32 KB
/
Makefile
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
# Copyright 2018 The Kubernetes Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Core Filestore CSI driver binary
DRIVERBINARY=gcp-filestore-csi-driver
WEBHOOKBINARY=gcp-filestore-csi-driver-webhook
$(info PULL_BASE_REF is $(PULL_BASE_REF))
$(info PWD is $(PWD))
# A space-separated list of image tags under which the current build is to be pushed.
# Note: For Cloud build jobs, build-image-and-push make rule is the entry point with PULL_BASE_REF initialized.
# PULL_BASE_REF is plumbed in to the docker build as a TAG, and this is used to setup GCP_FS_CSI_STAGING_VERSION.
STAGINGVERSION=
ifdef GCP_FS_CSI_STAGING_VERSION
STAGINGVERSION=${GCP_FS_CSI_STAGING_VERSION}
else
STAGINGVERSION=$(shell ./build/generate_image_tags.sh)
endif
$(info STAGINGVERSION is $(STAGINGVERSION))
STAGINGIMAGE=
ifdef GCP_FS_CSI_STAGING_IMAGE
STAGINGIMAGE=$(GCP_FS_CSI_STAGING_IMAGE)
else
STAGINGIMAGE=gcr.io/$(PROJECT)/gcp-filestore-csi-driver
endif
$(info STAGINGIMAGE is $(STAGINGIMAGE))
WEBHOOK_STAGINGIMAGE=
ifdef GCP_FS_CSI_WEBHOOK_STAGING_IMAGE
WEBHOOK_STAGINGIMAGE=$(GCP_FS_CSI_WEBHOOK_STAGING_IMAGE)
else
WEBHOOK_STAGINGIMAGE=gcr.io/$(PROJECT)/gcp-filestore-csi-driver-webhook
endif
$(info WEBHOOK_STAGINGIMAGE is $(WEBHOOK_STAGINGIMAGE))
BINDIR?=bin
# This flag is used only for csi-client and windows.
# TODO: Unify VERSION with STAGINGIMAGE
ifeq ($(VERSION),)
VERSION=latest
endif
all: image
# Build the go binary for the CSI driver webhook.
webhook:
mkdir -p ${BINDIR}
{ \
set -e ; \
CGO_ENABLED=0 go build -mod=vendor -a -ldflags '-X main.version=$(STAGINGVERSION) -extldflags "-static"' -o ${BINDIR}/${WEBHOOKBINARY} ./cmd/webhook/; \
}
# Build the docker image for the webhook.
webhook-image: init-buildx
{ \
set -e ; \
docker buildx build \
--platform linux/amd64 \
--build-arg STAGINGVERSION=$(STAGINGVERSION) \
--build-arg BUILDPLATFORM=linux/amd64 \
--build-arg TARGETPLATFORM=linux/amd64 \
-f ./cmd/webhook/Dockerfile \
-t $(WEBHOOK_STAGINGIMAGE):$(STAGINGVERSION) --push .; \
}
build-webhook-image-and-push-linux-amd64: init-buildx
{ \
set -e ; \
docker buildx build \
--platform linux/amd64 \
--build-arg STAGINGVERSION=$(STAGINGVERSION) \
--build-arg BUILDPLATFORM=linux/amd64 \
--build-arg TARGETPLATFORM=linux/amd64 \
-f ./cmd/webhook/Dockerfile \
-t $(WEBHOOK_STAGINGIMAGE):$(STAGINGVERSION)_linux_amd64 --push .; \
}
build-webhook-image-and-push-linux-arm64: init-buildx
{ \
set -e ; \
docker buildx build \
--platform linux/amd64 \
--build-arg STAGINGVERSION=$(STAGINGVERSION) \
--build-arg BUILDPLATFORM=linux/amd64 \
--build-arg TARGETPLATFORM=linux/arm64 \
-f ./cmd/webhook/Dockerfile \
-t $(WEBHOOK_STAGINGIMAGE):$(STAGINGVERSION)_linux_arm64 --push .; \
}
build-and-push-webhook-multi-arch: build-webhook-image-and-push-linux-arm64 build-webhook-image-and-push-linux-amd64
docker manifest create --amend $(WEBHOOK_STAGINGIMAGE):$(STAGINGVERSION) $(WEBHOOK_STAGINGIMAGE):$(STAGINGVERSION)_linux_amd64 $(WEBHOOK_STAGINGIMAGE):$(STAGINGVERSION)_linux_arm64
docker manifest push -p $(WEBHOOK_STAGINGIMAGE):$(STAGINGVERSION)
# Build the docker image for the core CSI driver.
build-image-and-push: init-buildx
{ \
set -e ; \
docker buildx build \
--platform linux/amd64 \
--build-arg STAGINGVERSION=$(STAGINGVERSION) \
--build-arg BUILDPLATFORM=linux/amd64 \
--build-arg TARGETPLATFORM=linux/amd64 \
-t $(STAGINGIMAGE):$(STAGINGVERSION) --push .; \
}
build-image-and-push-linux-amd64: init-buildx
{ \
set -e ; \
docker buildx build \
--platform linux/amd64 \
--build-arg STAGINGVERSION=$(STAGINGVERSION) \
--build-arg BUILDPLATFORM=linux/amd64 \
--build-arg TARGETPLATFORM=linux/amd64 \
-t $(STAGINGIMAGE):$(STAGINGVERSION)_linux_amd64 --push .; \
}
build-image-and-push-linux-arm64: init-buildx
{ \
set -e ; \
docker buildx build \
--platform linux/arm64 \
--build-arg STAGINGVERSION=$(STAGINGVERSION) \
--build-arg BUILDPLATFORM=linux/amd64 \
--build-arg TARGETPLATFORM=linux/arm64 \
-t $(STAGINGIMAGE):$(STAGINGVERSION)_linux_arm64 --push .; \
}
build-and-push-multi-arch: build-image-and-push-linux-arm64 build-image-and-push-linux-amd64
docker manifest create --amend $(STAGINGIMAGE):$(STAGINGVERSION) $(STAGINGIMAGE):$(STAGINGVERSION)_linux_amd64 $(STAGINGIMAGE):$(STAGINGVERSION)_linux_arm64
docker manifest push -p $(STAGINGIMAGE):$(STAGINGVERSION)
# Build the go binary for the CSI driver.
# STAGINGVERSION may contain multiple tags (e.g. canary, vX.Y.Z etc). Use one of the tags
# for setting the driver version variable. For convenience we are using the first value.
driver:
mkdir -p ${BINDIR}
{ \
set -e ; \
CGO_ENABLED=0 go build -mod=vendor -a -ldflags '-X main.version=$(STAGINGVERSION) -extldflags "-static"' -o ${BINDIR}/${DRIVERBINARY} ./cmd/; \
break; \
}
windows: windows-local
docker build -f test/experimental/Dockerfile --build-arg TAG=$(VERSION) -t $(IMAGE)-windows:$(VERSION) .
windows-local:
mkdir -p bin
GOOS=windows GOARCH=amd64 go build -ldflags "-X main.vendorVersion=${VERSION}" -o bin/gcfs-csi-driver.exe ./cmd/
skaffold-dev:
skaffold dev -f deploy/skaffold/skaffold.yaml
csi-client:
mkdir -p bin
go build -mod=vendor -ldflags "-X main.vendorVersion=${VERSION}" -o bin/csi-client ./hack/csi_client/cmd/
csi-client-windows:
mkdir -p bin
GOOS=windows GOARCH=amd64 go build -ldflags "-X main.vendorVersion=${VERSION}" -o bin/csi-client.exe ./hack/csi_client/cmd/
test-k8s-integration:
go build -mod=vendor -o bin/k8s-integration-test ./test/k8s-integration
init-buildx:
# Ensure we use a builder that can leverage it (the default on linux will not)
-docker buildx rm multiarch-multiplatform-builder
docker buildx create --use --name=multiarch-multiplatform-builder
docker run --rm --privileged multiarch/qemu-user-static --reset --credential yes --persistent yes
# Register gcloud as a Docker credential helper.
# Required for "docker buildx build --push".
gcloud auth configure-docker --quiet