101 lines
2.7 KiB
Markdown
101 lines
2.7 KiB
Markdown
# Build and Test Kilo
|
|
|
|
This document describes how you can build and test Kilo.
|
|
|
|
To follow along, you need to install the following utilities:
|
|
- `go` not for building but formatting the code and running unit tests
|
|
- `make`
|
|
- `jq`
|
|
- `git`
|
|
- `curl`
|
|
- `docker`
|
|
|
|
## Getting Started
|
|
|
|
Clone the Repository and `cd` into it.
|
|
```shell
|
|
git clone https://github.com/squat/kilo.git
|
|
cd kilo
|
|
```
|
|
|
|
## Build
|
|
|
|
For consistency, the Kilo binaries are compiled in a Docker container, so make sure the `docker` package is installed and the daemon is running.
|
|
|
|
### Compile Binaries
|
|
|
|
To compile the `kg` and `kgctl` binaries run:
|
|
```shell
|
|
make
|
|
```
|
|
Binaries are always placed in a directory corresponding to the local system's OS and architecture following the pattern `bin/<os>/<architecture>/`, so on an AMD64 machine running Linux, the binaries will be stored in `bin/linux/amd64/`.
|
|
|
|
You can build the binaries for a different architecture by setting the `ARCH` environment variable before invoking `make`, e.g.:
|
|
```shell
|
|
ARCH=<arm|arm64|amd64> make
|
|
```
|
|
|
|
Likewise, to build `kg` for another OS, set the `OS` environment variable before invoking `make`:
|
|
```shell
|
|
OS=<windows|darwin|linux> make
|
|
```
|
|
## Test
|
|
|
|
To execute the unit tests, run:
|
|
```shell
|
|
make unit
|
|
```
|
|
|
|
To lint the code in the repository, run:
|
|
```shell
|
|
make lint
|
|
```
|
|
|
|
To execute basic end to end tests, run:
|
|
```shell
|
|
make e2e
|
|
```
|
|
> **Note**: The end to end tests are currently flaky, so try running them again if they fail.
|
|
|
|
To instead run all of the tests with a single command, run:
|
|
```shell
|
|
make test
|
|
```
|
|
|
|
## Build and Push the Container Images
|
|
|
|
If you want to build containers for a processor architecture that is different from your computer's, then you will first need to configure QEMU as the interpreter for binaries built for non-native architectures:
|
|
```shell
|
|
docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
|
|
```
|
|
|
|
Set the `$IMAGE` environment variable to `<your Docker Hub user name>/kilo`.
|
|
This way the generated container images and manifests will be named accordingly.
|
|
By skipping this step, you will be able to tag images but will not be able to push the containers and manifests to your own Docker Hub.
|
|
```shell
|
|
export IMAGE=<docker hub user name>/kilo
|
|
```
|
|
|
|
If you want to use a different container registry, run:
|
|
```shell
|
|
export REGISTRY=<your registry without a trailing slash>
|
|
```
|
|
|
|
To build containers with the `kg` image for `arm`, `arm64` and `amd64`, run:
|
|
```shell
|
|
make all-container
|
|
```
|
|
|
|
Push the container images and build a manifest with:
|
|
```shell
|
|
make manifest
|
|
```
|
|
|
|
To tag and push the manifest with `latest`, run:
|
|
```shell
|
|
make manifest-latest
|
|
```
|
|
|
|
Now you can deploy the custom build of Kilo to your cluster.
|
|
If you are already running Kilo, change the image from `squat/kilo` to `[registry/]<username>/kilo[:sha]`.
|