Building Calico v2.6.x

Building Calico

The instructions specify the steps to build Calico version v2.6.10 on Linux on IBM Z for following distributions:

RHEL (7.3, 7.4, 7.5)
Ubuntu (16.04, 18.04)
SLES 12 SP3

General Notes:

When following the steps below please use a standard permission user unless otherwise specified.
A directory /<source_root>/ will be referred to in these instructions, this is a temporary writable directory anywhere you'd like to place it.

Prerequisites

Go -- Instructions for building Go can be found here.
Docker -- Instructions for install Docker can be found here (Docker-ce versions 17.06 - 18.02 have a known issue. Use Docker-ce version 18.03 and above or if you need to use an older version of docker, use 17.05 and below)
etcd -- Instructions for building etcd can be found here

Building Calico

1. Install the system dependencies

RHEL (7.3, 7.4, 7.5)

sudo yum install curl git wget tar gcc glibc-static.s390x make

SLES 12 SP3

sudo zypper install curl git wget tar gcc glibc-static.s390x make

Ubuntu (16.04, 18.04)

sudo apt-get update
sudo apt-get install git curl tar gcc wget make

2. Build `calicoctl` and `calico/node` image

2.1 Build `go-build`

This builds a docker image calico/go-build that is used to build other components

cd /<source_root>/
export GOPATH=`pwd`
git clone https://github.com/projectcalico/go-build $GOPATH/src/github.com/projectcalico/go-build
cd $GOPATH/src/github.com/projectcalico/go-build
git checkout v0.9

Create Dockerfile.s390x with following content

FROM s390x/golang:1.9.2-alpine3.6
MAINTAINER LoZ Open Source Ecosystem (https://www.ibm.com/developerworks/community/groups/community/lozopensource)

# Install su-exec for use in the entrypoint.sh (so processes run as the right user)
# Install bash for the entry script (and because it's generally useful)
# Install curl to download glide
# Install git for fetching Go dependencies
# Install ssh for fetching Go dependencies
# Install mercurial for fetching go dependencies
# Install wget for fetching glibc
# Install make for building things
# Install util-linux for column command (used for output formatting).
RUN apk add --no-cache su-exec curl bash git openssh mercurial make wget util-linux tini
RUN apk upgrade --no-cache

# Disable ssh host key checking
RUN echo 'Host *' >> /etc/ssh/ssh_config
RUN echo '    StrictHostKeyChecking no' >> /etc/ssh/ssh_config

# Install glibc
RUN wget -q -O /etc/apk/keys/sgerrand.rsa.pub https://raw.githubusercontent.com/sgerrand/alpine-pkg-glibc/master/sgerrand.rsa.pub
RUN wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.23-r3/glibc-2.23-r3.apk
RUN apk add glibc-2.23-r3.apk

# Disable cgo so that binaries we build will be fully static.
ENV CGO_ENABLED=0

# Recompile the standard library with cgo disabled.  This prevents the standard library from being
# marked stale, causing full rebuilds every time.
RUN go install -v std

# Install glide
RUN go get github.com/Masterminds/glide
ENV GLIDE_HOME /home/user/.glide

# Install ginkgo CLI tool for running tests
RUN go get github.com/onsi/ginkgo/ginkgo

# Install linting tools.  We pin gometalinter to a working master revision to pick up
# a go v1.9 compatibility patch that hasn't been released.
RUN go get -u -d github.com/alecthomas/gometalinter && \
    cd /go/src/github.com/alecthomas/gometalinter && \
    git checkout cc4415ed09f7073d595ee504cad4d98b71a3038e && \
    go install github.com/alecthomas/gometalinter
RUN ln -s `which gometalinter` /usr/local/bin/gometalinter
RUN gometalinter --install

# Install license checking tool.
RUN go get github.com/pmezard/licenses

# Install tool to merge coverage reports.
RUN go get github.com/wadey/gocovmerge

RUN go get github.com/mikefarah/yaml

# Install patched version of goveralls (upstream is bugged if not used from Travis).
RUN go get -u -d github.com/fasaxc/goveralls && \
  cd /go/src/github.com/fasaxc/goveralls && \
  git checkout tags/v0.0.1-smc && \
  go install github.com/fasaxc/goveralls

# Ensure that everything under the GOPATH is writable by everyone
RUN chmod -R 777 $GOPATH

COPY entrypoint.sh /usr/local/bin/entrypoint.sh
ENTRYPOINT ["/sbin/tini", "--", "/usr/local/bin/entrypoint.sh"]

Modify Makefile as follows

@@ -4,3 +4,6 @@ calico/go-build:

 calico/go-build-ppc64le:
        docker build --pull -t calico/go-build-ppc64le -f Dockerfile.ppc64le .
+
+calico/go-build-s390x:
+               docker build --pull -t calico/go-build-s390x -f Dockerfile.s390x .

Build calico/go-build image

make calico/go-build-s390x
docker tag calico/go-build-s390x:latest calico/go-build:latest

2.2 Build `calicoctl` binary and `calico/ctl` image

Download the source code

git clone https://github.com/projectcalico/calicoctl $GOPATH/src/github.com/projectcalico/calicoctl
cd $GOPATH/src/github.com/projectcalico/calicoctl
git checkout v1.6.4

Modify Makefile as follows

@@ -80,9 +80,16 @@ dist/calicoctl: $(CALICOCTL_FILES) vendor
        $(MAKE) dist/calicoctl-linux-amd64
        mv dist/calicoctl-linux-amd64 dist/calicoctl

+dist/calicoctl-s390x: $(CALICOCTL_FILES) vendor
+       $(MAKE) dist/calicoctl-linux-s390x
+       mv dist/calicoctl-linux-s390x dist/calicoctl
+
 dist/calicoctl-linux-amd64: $(CALICOCTL_FILES) vendor
        $(MAKE) OS=linux ARCH=amd64 binary-containerized

+dist/calicoctl-linux-s390x: $(CALICOCTL_FILES) vendor
+       $(MAKE) OS=linux ARCH=s390x binary-containerized
+
 dist/calicoctl-darwin-amd64: $(CALICOCTL_FILES) vendor
        $(MAKE) OS=darwin ARCH=amd64 binary-containerized

Build the calicoctl binary

docker tag calico/go-build calico/go-build:v0.8
make  dist/calicoctl-s390x

Modify calicoctl/Dockerfile.calicoctl as follows

@@ -1,4 +1,4 @@
-FROM alpine:3.4
+FROM s390x/alpine:3.6
 MAINTAINER Tom Denham <tom@projectcalico.org>

 ADD dist/calicoctl ./calicoctl
@@ -6,16 +6,5 @@
 ENV CALICO_CTL_CONTAINER=TRUE
 ENV PATH=$PATH:/

-# glibc and libltdl are needed by docker command line tool
-ENV GLIBC_VERSION 2.23-r3
-RUN apk add --no-cache libltdl
-RUN apk add --no-cache --update wget openssl ca-certificates && \
-  wget -q -O /etc/apk/keys/sgerrand.rsa.pub https://raw.githubusercontent.com/sgerrand/alpine-pkg-glibc/master/sgerrand.rsa.pub && \
-  wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/${GLIBC_VERSION}/glibc-${GLIBC_VERSION}.apk && \
-  wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/${GLIBC_VERSION}/glibc-bin-${GLIBC_VERSION}.apk && \
-  apk add glibc-${GLIBC_VERSION}.apk glibc-bin-${GLIBC_VERSION}.apk && \
-  rm -f glibc-${GLIBC_VERSION}.apk glibc-bin-${GLIBC_VERSION}.apk && \
-  apk del openssl ca-certificates wget
-
 WORKDIR /root
 ENTRYPOINT ["/calicoctl"]

Build the calico/ctl image

make  calico/ctl
docker tag calico/ctl calico/ctl:v1.6.4

2.3 Build `bird`

Download the source code

git clone https://github.com/projectcalico/bird $GOPATH/src/github.com/projectcalico/bird
cd $GOPATH/src/github.com/projectcalico/bird
git checkout v0.3.2

Create Dockerfile-s390x with following content

FROM s390x/alpine:3.6
MAINTAINER LoZ Open Source Ecosystem (https://www.ibm.com/developerworks/community/groups/community/lozopensource)

RUN apk update
RUN apk add alpine-sdk linux-headers autoconf flex bison ncurses-dev readline-dev

WORKDIR /code

Modify build.sh as follows

@@ -14,6 +14,10 @@ if [ $ARCH = ppc64le ]; then
     ARCHTAG=-ppc64le
fi

+if [ $ARCH = s390x ]; then
+        ARCHTAG=-s390x
+fi
+
DIST=dist/$ARCH

docker build -t birdbuild$ARCHTAG -f Dockerfile$ARCHTAG .

Run build.sh to build 3 executable files (in dist/s390x/)
```
ARCH=s390x ./build.sh
```

2.4 Build `confd`

Download the source code

git clone https://github.com/projectcalico/confd $GOPATH/src/github.com/projectcalico/confd
cd $GOPATH/src/github.com/projectcalico/confd
git checkout v0.12.1-calico-0.4.4

Modify Dockerfile to change FROM alpine to FROM s390x/alpine:3.6
Build the confd binaries
```
make container
```

2.5 Build `libnetwork-plugin`

Download the source code

docker tag calico/go-build:latest calico/go-build:v0.9
docker tag calico/go-build:latest calico/go-build:v0.12
git clone https://github.com/projectcalico/libnetwork-plugin $GOPATH/src/github.com/projectcalico/libnetwork-plugin
cd $GOPATH/src/github.com/projectcalico/libnetwork-plugin
git checkout v1.1.3

Create Dockerfile-s390x with following content

FROM s390x/alpine:3.6
MAINTAINER LoZ Open Source Ecosystem (https://www.ibm.com/developerworks/community/groups/community/lozopensource)

ADD dist/s390x/libnetwork-plugin /libnetwork-plugin
ENTRYPOINT ["/libnetwork-plugin"]

Modify Makefile as follows

@@ -17,6 +17,13 @@ ifeq ($(ARCH),ppc64le)
        DIND_IMAGE?=ppc64le/docker:dind
 endif

+ifeq ($(ARCH),s390x)
+        ARCHTAG:=-s390x
+        GO_BUILD_VER?=latest
+        BUSYBOX_IMAGE?=s390x/busybox:latest
+        DIND_IMAGE?=s390x/docker:dind
+endif
+
 # Disable make's implicit rules, which are not useful for golang, and slow down the build
 # considerably.
 .SUFFIXES:

Build libnetwork-plugin binary and image

ARCH=s390x make calico/libnetwork-plugin-s390x

2.6 Build `felix`

To build felix it needs felixbackend.pb.go that is generated by a docker image calico/protoc. Let's first built this image.

git clone https://github.com/tigera/docker-protobuf $GOPATH/src/github.com/projectcalico/docker-protobuf
cd  $GOPATH/src/github.com/projectcalico/docker-protobuf

Modify Dockerfile as follows

@@ -1,4 +1,4 @@
-FROM golang:1.9.2
+FROM s390x/golang:1.9.2

 MAINTAINER Shaun Crampton <shaun@tigera.io>

@@ -7,14 +7,14 @@ RUN apt-get update && apt-get install -y git make autoconf automake libtool unzi
 # Clone the initial protobuf library down
 RUN mkdir -p /src
 WORKDIR /src
-ENV PROTOBUF_TAG v3.5.1
+ENV PROTOBUF_TAG v3.4.1
 RUN git clone https://github.com/google/protobuf

 # Switch to protobuf folder and carry out build
 WORKDIR /src/protobuf
 RUN git checkout ${PROTOBUF_TAG}
 # Cherry pick specific for big endian systems, see https://github.com/google/protobuf/pull/3955
-RUN git cherry-pick -n 642e1ac635f2563b4a14c255374f02645ae85dac
+#RUN git cherry-pick -n 642e1ac635f2563b4a14c255374f02645ae85dac
 RUN ./autogen.sh && ./configure --prefix=/usr
 RUN make -j 3
 RUN make check install

Build docker image calico/protoc

docker build -t calico/protoc .
docker tag calico/protoc calico/protoc-s390x

Build felix

Download the source code

git clone https://github.com/projectcalico/felix $GOPATH/src/github.com/projectcalico/felix
cd $GOPATH/src/github.com/projectcalico/felix
git checkout 2.6.7

Modify Makefile as follows

@@ -59,6 +59,10 @@ ifeq ($(ARCH),ppc64le)
 GO_BUILD_VER:=latest
 endif

+ifeq ($(ARCH),s390x)
+GO_BUILD_VER:=latest
+endif
+
 GO_BUILD_CONTAINER?=calico/go-build$(ARCHTAG):$(GO_BUILD_VER)

 help:

Change directory to docker-image folder
```
cd docker-image
```

Create Dockerfile-s390x with following content

FROM s390x/alpine:3.6
MAINTAINER LoZ Open Source Ecosystem (https://www.ibm.com/developerworks/community/groups/community/lozopensource)

# Since our binary isn't designed to run as PID 1, run it via the tini init daemon.
RUN apk --no-cache add --update tini
ENTRYPOINT ["/sbin/tini", "--"]

# Install Felix's dependencies.
RUN apk --no-cache add ip6tables ipset iputils iproute2 conntrack-tools

ADD felix.cfg /etc/calico/felix.cfg

# Put out binary in /code rather than directly in /usr/bin.  This allows the downstream builds
# to more easily extract the Felix build artefacts from the container.
RUN mkdir /code
ADD bin/calico-felix /code
WORKDIR /code
RUN ln -s /code/calico-felix /usr/bin

# Run felix by default
CMD ["calico-felix"]

Build the felix binaries

cd $GOPATH/src/github.com/projectcalico/felix
ARCH=s390x make calico/felix

2.7 Build `Typha`

Download the source code

git clone https://github.com/projectcalico/typha $GOPATH/src/github.com/projectcalico/typha
cd $GOPATH/src/github.com/projectcalico/typha
git checkout v0.5.7

Modify docker-image/Dockerfile to change FROM alpine:3.4 to FROM s390x/alpine:3.6
Build the binaries and docker image for typha
```
make calico/typha
```

2.8 Build `calico-bgp-daemon`

Download the source code

git clone https://github.com/projectcalico/calico-bgp-daemon $GOPATH/src/github.com/projectcalico/calico-bgp-daemon
cd $GOPATH/src/github.com/projectcalico/calico-bgp-daemon
git checkout v0.2.2

Modify Dockerfile to change FROM alpine:3.4 to FROM s390x/alpine:3.6 and run
```
make build-containerized
```

2.9 Build image `calico/node`

Download the source code

git clone https://github.com/projectcalico/calico $GOPATH/src/github.com/projectcalico/calico
cd $GOPATH/src/github.com/projectcalico/calico
git checkout v2.6.10

Modify calico_node/Makefile as follows

@@ -202,7 +202,7 @@ $(NODE_CONTAINER_BIN_DIR)/confd:
        -docker rm -f calico-confd
        # Latest confd binaries are stored in automated builds of calico/confd.
        # To get them, we create (but don't start) a container from that image.
-       docker pull $(CONFD_CONTAINER_NAME)
+       #docker pull $(CONFD_CONTAINER_NAME)
        docker create --name calico-confd $(CONFD_CONTAINER_NAME)
        # Then we copy the files out of the container.  Since docker preserves
        # mtimes on its copy, check the file really did appear, then touch it
@@ -238,7 +238,7 @@ $(NODE_CONTAINER_BIN_DIR)/allocate-ipip-addr: dist/allocate-ipip-addr
 ## Build startup.go
 .PHONY: startup
 startup:
-       GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -v -i -o dist/startup $(LDFLAGS) startup/startup.go
+       GOOS=linux GOARCH=s390x CGO_ENABLED=0 go build -v -i -o dist/startup $(LDFLAGS) startup/startup.go

 dist/startup: $(STARTUP_FILES) vendor
        mkdir -p dist
@@ -257,7 +257,7 @@ dist/startup: $(STARTUP_FILES) vendor
 ## Build allocate_ipip_addr.go
 .PHONY: allocate-ipip-addr
 allocate-ipip-addr:
-       GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -v -i -o dist/allocate-ipip-addr $(LDFLAGS) allocateipip/allocate_ipip_addr.go
+       GOOS=linux GOARCH=s390x CGO_ENABLED=0 go build -v -i -o dist/allocate-ipip-addr $(LDFLAGS) allocateipip/allocate_ipip_addr.go

 dist/allocate-ipip-addr: $(ALLOCATE_IPIP_FILES) vendor
        mkdir -p dist
@@ -320,11 +320,11 @@ certs/.certificates.created:
        touch certs/.certificates.created

 busybox.tar:
-       docker pull busybox:latest
+       #docker pull busybox:latest
        docker save --output busybox.tar busybox:latest

 routereflector.tar:
-       docker pull calico/routereflector:$(RR_VER)
+       #docker pull calico/routereflector:$(RR_VER)
        docker save --output routereflector.tar calico/routereflector:$(RR_VER)

 workload.tar:
@@ -639,17 +639,17 @@ $(RELEASE_DIR_IMAGES)/calico-node.tar:

 $(RELEASE_DIR_IMAGES)/calico-typha.tar:
        mkdir -p $(RELEASE_DIR_IMAGES)
-       docker pull calico/typha:$(TYPHA_VER)
+       #docker pull calico/typha:$(TYPHA_VER)
        docker save --output $@ calico/typha:$(TYPHA_VER)

 $(RELEASE_DIR_IMAGES)/calico-cni.tar:
        mkdir -p $(RELEASE_DIR_IMAGES)
-       docker pull calico/cni:$(CNI_VER)
+       #docker pull calico/cni:$(CNI_VER)
        docker save --output $@ calico/cni:$(CNI_VER)

 $(RELEASE_DIR_IMAGES)/calico-kube-controllers.tar:
        mkdir -p $(RELEASE_DIR_IMAGES)
-       docker pull calico/kube-controllers:$(KUBE_CONTROLLERS_VER)
+       #docker pull calico/kube-controllers:$(KUBE_CONTROLLERS_VER)
        docker save --output $@ calico/kube-controllers:$(KUBE_CONTROLLERS_VER)

 $(RELEASE_DIR_BIN)/%:

Modify calico_node/Dockerfile as follows

@@ -11,27 +11,14 @@
 # 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.
-FROM alpine
+FROM s390x/alpine:3.6
 MAINTAINER Tom Denham <tom@projectcalico.org>

 # Set the minimum Docker API version required for libnetwork.
 ENV DOCKER_API_VERSION 1.21

-# Download and install glibc for use by non-static binaries that require it.
-RUN apk --no-cache add wget ca-certificates libgcc && \
-    wget -q -O /etc/apk/keys/sgerrand.rsa.pub https://raw.githubusercontent.com/sgerrand/alpine-pkg-glibc/master/sgerrand.rsa.pub && \
-    wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.23-r3/glibc-2.23-r3.apk && \
-    wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.23-r3/glibc-bin-2.23-r3.apk && \
-    apk add glibc-2.23-r3.apk glibc-bin-2.23-r3.apk && \
-    /usr/glibc-compat/sbin/ldconfig /lib /usr/glibc/usr/lib && \
-    apk del wget && \
-    rm -f glibc-2.23-r3.apk glibc-bin-2.23-r3.apk
-
-# Install runit from the community repository, as its not yet available in global
-RUN apk add --no-cache --repository "http://alpine.gliderlabs.com/alpine/edge/community" runit
-
 # Install remaining runtime deps required for felix from the global repository
-RUN apk add --no-cache ip6tables ipset iputils iproute2 conntrack-tools
+RUN apk add --no-cache ip6tables ipset iputils iproute2 conntrack-tools runit file

 # Copy in the filesystem - this contains felix, bird, calico-bgp-daemon etc...
 COPY filesystem /

Get the yaml binary if not installed, needed for building calico/node
```
go get github.com/mikefarah/yaml
export PATH=$PATH:$GOPATH/bin
```

Build calico/node

cd $GOPATH/src/github.com/projectcalico/calico/calico_node
make dist/calicoctl
mkdir filesystem/bin
cp $GOPATH/src/github.com/projectcalico/bird/dist/s390x/* filesystem/bin
cp $GOPATH/src/github.com/projectcalico/confd/bin/confd filesystem/bin
cp $GOPATH/src/github.com/projectcalico/libnetwork-plugin/dist/s390x/libnetwork-plugin filesystem/bin
cp $GOPATH/src/github.com/projectcalico/felix/bin/calico-felix filesystem/bin
cp $GOPATH/src/github.com/projectcalico/calico-bgp-daemon/dist/* filesystem/bin
make calico/node

2.10 Start `calico/node`

First start etcd that is required by running calico/node

etcd --listen-client-urls=http://<host-ip>:2379 --advertise-client-urls=http://<host-ip>:2379

Tag image calico/node to quay.io/calico/node

docker tag  calico/node quay.io/calico/node:v2.6.10

Start calico/node

cd  $GOPATH/src/github.com/projectcalico/calico/calico_node
ETCD_ENDPOINTS=http://<host_run_etcd_ip>:2379 dist/calicoctl node run --node-image=quay.io/calico/node:v2.6.10

Check the output and confirm that calico/node is successfully started.

2.11 Calico testcases (Optional)

Build etcd

cd $GOPATH/src/github.com/projectcalico/
git clone https://github.com/coreos/etcd
cd etcd
git checkout v3.3.1

Modify Dockerfile-release as follows

@@ -1,7 +1,9 @@
-FROM alpine:latest
+FROM s390x/alpine:3.6
+
+ADD bin/etcd /usr/local/bin/
+ADD bin/etcdctl /usr/local/bin/
+ENV ETCD_UNSUPPORTED_ARCH=s390x

-ADD etcd /usr/local/bin/
-ADD etcdctl /usr/local/bin/
RUN mkdir -p /var/etcd/
RUN mkdir -p /var/lib/etcd/

Then build etcd and image

./build
docker build -f Dockerfile-release  -t quay.io/coreos/etcd .
cd bin
tar cvf etcd-v3.3.1-linux-s390x.tar etcd etcdctl
gzip etcd-v3.3.1-linux-s390x.tar

Build CNI plugins binaries and CNI image

sudo mkdir -p /opt/cni/bin
git clone https://github.com/projectcalico/cni-plugin.git $GOPATH/src/github.com/projectcalico/cni-plugin
cd $GOPATH/src/github.com/projectcalico/cni-plugin
git checkout v1.11.6
mkdir dist

Modify Dockerfile to change FROM busybox to FROM s390x/busybox

Modify Makefile as follows

@@ -111,7 +111,7 @@ fetch-cni-bins: dist/flannel dist/loopback dist/host-local dist/portmap

 dist/flannel dist/loopback dist/host-local dist/portmap:
        mkdir -p dist
-       $(CURL) -L --retry 5 https://github.com/containernetworking/plugins/releases/download/$(CNI_VERSION)/cni-plugins-amd64-$(CNI_VERSION).tgz | tar -xz -C dist ./flannel ./loopback ./host-local ./portmap
+       $(CURL) -L --retry 5 https://github.com/containernetworking/plugins/releases/download/$(CNI_VERSION)/cni-plugins-s390x-$(CNI_VERSION).tgz | tar -xz -C dist ./flannel ./loopback ./host-local ./portmap

 # Useful for CI but currently slow for local development because the
 # .go-pkg-cache can't be used (since tests run as root)

Then build CNI binaries and image

make docker-image
sudo cp dist/* /opt/cni/bin
docker tag calico/cni:latest quay.io/calico/cni:v1.11.6

Build calico/routereflector

git clone https://github.com/projectcalico/bird.git $GOPATH/src/github.com/projectcalico/routereflector
cd $GOPATH/src/github.com/projectcalico/routereflector
git checkout rr-v0.4.2
cd build_routereflector/
cp $GOPATH/src/github.com/projectcalico/bird/dist/s390x/* image/
cp $GOPATH/src/github.com/projectcalico/confd/bin/confd  image/
docker tag calico/confd calico/confd:v1.0.0-beta1-4-g4619952

Modify Dockerfile as follows

@@ -14,7 +14,10 @@

# For details and docs - see https://github.com/phusion/baseimage-docker#getting_started

-FROM ubuntu:14.04
+FROM s390x/ubuntu:16.04
+
+RUN apt-get update && \
+       apt-get install -y python3-minimal

CMD ["/sbin/my_init"]

Modify image/install.sh as follows

@@ -19,25 +19,23 @@ $minimal_apt_get_install software-properties-common
 # Install curl, needed below for manual BIRD install.
 $minimal_apt_get_install curl

-# Find the list of packages just installed - these can be deleted later.
-grep -Fxvf  /tmp/base.txt <(dpkg -l | grep ^ii | sed 's_  _\t_g' | cut \
--f 2) >/tmp/add-apt.txt
-
-# Add new repos and update again
-LC_ALL=C.UTF-8 LANG=C.UTF-8 add-apt-repository -y ppa:cz.nic-labs/bird
-apt-get update

 # Install packages that should not be removed in the cleanup processing.
 # - bird and bird6
 # - packages required by felix
 # - pip (which includes various setuptools package discovery).
 $minimal_apt_get_install \
-        bird \
-        bird6
+        bird
+
+cp build/bir* /usr/sbin/

 # Install Confd
-curl -L https://github.com/projectcalico/confd/releases/download/v0.12.1-calico-0.4.3/confd -o confd
-chmod +x confd
+#curl -L https://github.com/projectcalico/confd/releases/download/v0.12.1-calico-0.4.3/confd -o confd
+#chmod +x confd
+cp build/confd /
+chmod +x /confd
+
+apt-get install -y python3

 # Create the config directory for confd
 mkdir config

Modify image/cleanup.sh as follows

@@ -5,8 +5,6 @@ set -x
 # Remove extra packages using dpkg rather than apt-get - this prevents us from
 # deleting dependent packages that we still require.
 # - Remove any temporary packages installed in the install.sh script.
-echo "Removing extra packages"
-cat /tmp/add-apt.txt | xargs xargs dpkg -r --force-depends

 # Remove any other junk created during installation that is not required.
 apt-get clean

Build the routereflector

cd $GOPATH/src/github.com/projectcalico/routereflector/build_routereflector/
make
docker tag calico/routereflector:latest calico/routereflector:v0.4.2

Build calico/dind

git clone https://github.com/projectcalico/dind $GOPATH/src/github.com/projectcalico/dind
cd $GOPATH/src/github.com/projectcalico/dind

Create Dockerfile-s390x with following content

FROM s390x/docker:17-dind
MAINTAINER LoZ Open Source Ecosystem (https://www.ibm.com/developerworks/community/groups/community/lozopensource)

RUN apk update && apk add --update iptables ip6tables ipset iproute2 curl busybox-extras && \
echo 'hosts: files mdns4_minimal [NOTFOUND=return] dns mdns4' >> /etc/nsswitch.conf && \
rm -rf /var/cache/apk/*

Build the dind

docker build -t calico/dind -f Dockerfile-s390x .

Build calico/test

cd $GOPATH/src/github.com/projectcalico/calico/calico_node/calico_test/
mkdir pkg
cp $GOPATH/src/github.com/projectcalico/etcd/bin/etcd-v3.3.1-linux-s390x.tar.gz pkg

Modify the Dockerfile.calico_test as follows

@@ -32,7 +32,7 @@
# - eliminate most isolation, (--uts=host --pid=host --net=host --privileged)
# - volume mount your ST source code
# - run 'nosetests'
-FROM docker:1.13.0
+FROM s390x/docker:18.03.0
MAINTAINER Tom Denham <tom@projectcalico.org>

# Running STs in this container requires that it has all dependencies installed
@@ -45,11 +45,13 @@ RUN apk add --update python python-dev py2-pip py-setuptools openssl-dev libffi-
COPY requirements.txt /requirements.txt
RUN pip install -r /requirements.txt

+RUN apk update \
+&&   apk add ca-certificates wget \
+&&   update-ca-certificates
+
# Install etcdctl
-RUN wget https://github.com/coreos/etcd/releases/download/v2.3.3/etcd-v2.3.3-linux-amd64.tar.gz && \
-    tar -xzf etcd-v2.3.3-linux-amd64.tar.gz && \
-    cd etcd-v2.3.3-linux-amd64 && \
-    ln -s etcdctl /usr/local/bin/
+COPY pkg /pkg/
+RUN tar -xzf pkg/etcd-v3.3.1-linux-s390x.tar.gz -C /usr/local/bin/

# The container is used by mounting the code-under-test to /code
WORKDIR /code/

Run the test cases

cd $GOPATH/src/github.com/projectcalico/calico/calico_node
cp dist/calicoctl dist/calicoctl-v1.0.2
docker pull s390x/busybox
docker tag s390x/busybox busybox
docker pull s390x/nginx
docker tag s390x/nginx nginx
docker tag calico/routereflector calico/routereflector:v0.4.2
docker tag calico/cni calico/cni:v1.11.6

Modify workload/Dockerfile as follows

@@ -1,4 +1,4 @@
-FROM alpine:3.4
+FROM s390x/alpine:3.6
RUN apk add --no-cache \
   python \
   netcat-openbsd

Run test cases

make st

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Building Calico v2.6.x

Building Calico

Prerequisites

Building Calico

1. Install the system dependencies

2. Build `calicoctl` and `calico/node` image

2.1 Build `go-build`

2.2 Build `calicoctl` binary and `calico/ctl` image

2.3 Build `bird`

2.4 Build `confd`

2.5 Build `libnetwork-plugin`

2.6 Build `felix`

2.7 Build `Typha`

2.8 Build `calico-bgp-daemon`

2.9 Build image `calico/node`

2.10 Start `calico/node`

2.11 Calico testcases (Optional)

3. Calico Integration

3. 1 Calico with Docker

3. 2 Calico with Kubernetes

3. 3 Calico with Host Protection

3. 4 Calico with Mesos

References:

Clone this wiki locally

Building Calico v2.6.x

Building Calico

Prerequisites

Building Calico

1. Install the system dependencies

2. Build calicoctl and calico/node image

2.1 Build go-build

2.2 Build calicoctl binary and calico/ctl image

2.3 Build bird

2.4 Build confd

2.5 Build libnetwork-plugin

2.6 Build felix

2.7 Build Typha

2.8 Build calico-bgp-daemon

2.9 Build image calico/node

2.10 Start calico/node

2.11 Calico testcases (Optional)

3. Calico Integration

3. 1 Calico with Docker

3. 2 Calico with Kubernetes

3. 3 Calico with Host Protection

3. 4 Calico with Mesos

References:

Clone this wiki locally

2. Build `calicoctl` and `calico/node` image

2.1 Build `go-build`

2.2 Build `calicoctl` binary and `calico/ctl` image

2.3 Build `bird`

2.4 Build `confd`

2.5 Build `libnetwork-plugin`

2.6 Build `felix`

2.7 Build `Typha`

2.8 Build `calico-bgp-daemon`

2.9 Build image `calico/node`

2.10 Start `calico/node`