How to Automate CI/CD Pipeline with Walrus and GitLab
Tags: devops, kubernetes, cicd, tutorial
Published: 2024-02-27 16:00:00

`Walrus file` is a new feature released in [Walrus 0.5](https://github.com/seal-io/walrus/releases/tag/v0.5.1). It allows you to describe applications and configure infrastructure resources using a concise `YAML`. You can then execute walrus apply in the Walrus CLI or import it on the Walrus UI. This will submit the Walrus file to the Walrus server, which will deploy, configure, and manage applications and infrastructure resources. This makes it easy to reuse them across multiple environments.

In this tutorial, we will demonstrate how to integrate Walrus CLI with GitLab CI and release applications via Walrus file to improve CI/CD pipelines.

## Prerequisites
Before getting started, please prepare:

1. Create a new project on GitLab and import [our demo project](https://github.com/seal-demo/2048) into it. First, ensure that you have the GitHub type `Import Project` permission enabled. If not, refer to the snapshot below and enable it in the `Admin Area`.
![create-new-project](https://raw.githubusercontent.com/Aleegra/seallogo/main/imgcreate-new-project.png)
Alternatively, you can manually `git clone` the project and push a new GitLab project into it.

2. Install Walrus via docker run, and expose additional ports `30000~30100` for NodePort of built-in k3s cluster workload, for more information: https://seal-io.github.io/docs/deploy/standalone
```
sudo docker run -d --privileged --restart=always -p 80:80 -p 443:443 -p 30000-30100:30000-30100 --name walrus sealio/walrus:v0.5.1
```

3.Access Walrus. In the latest version, Walrus automatically creates a `local` environment in the `default` project and adds built-in K3s or other K8s clusters in the Walrus container as a connector in this environment. For demonstration purposes, this example will use the K3s cluster.

4.Create an `API key` on Walrus to authenticate for communication between the Walrus CLI and Walrus Server in following steps. Here is the guidance:

* Navigate to `Account>User center>API Keys`

* Click `New Key`, name it and set up expiration

* After configuring, copy the generated key and save it. If the key is lost in the future, it can be regenerated for replacement.
![create-API-Key](https://raw.githubusercontent.com/Aleegra/seallogo/main/imgcreate-API-Key.png)

## Configure Walrus CLI and Integrate it with GitLab CI

In this section, we will demonstrate an example from CI to CD. Follow the steps below to integrate Walrus CLI with GitLab CI:

1. Access GitLab and navigate to `Admin Area > Settings > CI/CD > Variables`

2. Add following variables, configure the sensitive information that is required by GitLab CI execution:

* `CI_REGISTRY_USERNAME`: The username of the CI build container image to push to Docker Hub, refer to docker login.

* `CI_REGISTRY_PASSWORD`: The password of the CI build container image to push to Docker Hub, refer to docker login.

* `CD_WALRUS_SERVER`: The URL that Walrus accesses, whose format is `https://domain:port`.

* `CD_WALRUS_TOKEN`: API Keys of Walrus for authentication.

![config-gitlab-secrets](https://raw.githubusercontent.com/Aleegra/seallogo/main/imgconfig-gitlab-secrets.png)

3.Create `.gitlab-ci.yml` file in the GitLab project (exists by default in the sample project), which will define your CI/CD workflow. Below is a sample `.gitlab-ci.yml` file for deploying the sample project `Game 2048`. You can copy and modify it as needed, such as changing the image `sealdemo/game2048` to your own image name.

```
stages:
  - compile
  - build
  - deploy

variables:
  CI_PROJECT_DIR: ./
  CI_IMAGE_NAME: sealdemo/game2048
  CD_WALRUS_PROJECT: default
  CD_WALRUS_PROJECT_ENV: local

compile:
  stage: compile
  image: maven:3-openjdk-8
  artifacts:
    paths:
      - target/
  script:
    - mvn clean package

build:
  dependencies:
  - compile
  stage: build
  image:
    name: gcr.io/kaniko-project/executor:debug
    entrypoint: [""]
  artifacts:
    paths:
      - target/
  before_script:
    - mkdir -p /kaniko/.docker
    - echo "{\"auths\":{\"https://index.docker.io/v1/\":{\"auth\":\"$(printf "%s:%s" "${CI_REGISTRY_USERNAME}" "${CI_REGISTRY_PASSWORD}" | base64 | tr -d '\n')\"}}}" > /kaniko/.docker/config.json
  script:
    - /kaniko/executor
      --context "${CI_PROJECT_DIR}"
      --dockerfile "${CI_PROJECT_DIR}/Dockerfile"
      --destination "${CI_IMAGE_NAME}:${CI_COMMIT_SHORT_SHA}"

deploy:
  stage: deploy
  image: alpine
  before_script:
    - wget -O walrus --no-check-certificate "${CD_WALRUS_SERVER}/cli?arch=amd64&os=linux"
    - chmod +x ./walrus
  script:
    - ./walrus login --insecure --server ${CD_WALRUS_SERVER} --token ${CD_WALRUS_TOKEN}
    - ./walrus apply -f ./walrus-file.yaml -p ${CD_WALRUS_PROJECT} -e ${CD_WALRUS_PROJECT_ENV}
```
4.Check out `walrus-file.yaml`, which Walrus uses to deploy applications (already exists by default in the sample project). `Walrus file` is a concise `YAML` structure that describes the application's deployment configuration. You can make any necessary changes to this file:

```
version: v1
resources:
- name: game2048
  type: containerservice
  attributes:
    containers:
    - profile: run
      image: ${CI_IMAGE_NAME}:${CI_COMMIT_SHORT_SHA}
      ports:
      - schema: http
        external: 8080
        internal: 8080
        protocol: tcp
      resources:
        cpu: 0.25
        memory: 512
```

5.Access GitLab, navigate to `Admin Area > CI/CD > Runners`, check that GitLab Runner is online properly([how to install GitLab Runner](https://docs.gitlab.com/runner/install/)), which is used to run the CI/CD pipeline defined by `.gitlab-ci.yml`:
![gitlab-runner](https://raw.githubusercontent.com/Aleegra/seallogo/main/imggitlab-runner.png)

6.Navigate to `2048 Project > Build > Pipelines`, select `Run pipeline`.

![run-pipelines](https://raw.githubusercontent.com/Aleegra/seallogo/main/imgrun-pipelines.png)

Wait for the pipeline to finish running and check the results of the pipeline run: 
![result-pipepline](https://raw.githubusercontent.com/Aleegra/seallogo/main/imgresult-pipepline.png)

View the pipeline's running logs:
![pipeline-logs](https://raw.githubusercontent.com/Aleegra/seallogo/main/imgpipeline-logs.png)

The logs indicate that the pipeline ran successfully. GitLab CI completed the CI/CD steps of `Maven` build, container image build upload, and application deployment to the K3s cluster using the Walrus CLI, in that specific order.

7.After successfully running the pipelines, you can visit Walrus to view the deployed `game2048` application!

![walrus-game2048](https://raw.githubusercontent.com/Aleegra/seallogo/main/imgwalrus-game2048.png)

Access the 2048 game by using automatically recognized endpoints and the `/2048` path. Here is the full URL: `http://domain:port/2048`.

![game-2048](https://raw.githubusercontent.com/Aleegra/seallogo/main/imggame-2048.png)

Now, we have successfully integrated Walrus CLI with GitLab CI. By using the `Walrus file` in Walrus 0.5.x, developers can now automate the deployment of applications in a more user-friendly way when committing application code to GitLab.

With XaC (Everything is Code), Walrus can unify and manage the entire application lifecycle, from the provisioning infrastructure resources to releasing the upper tier application. This tutorial only covers one scenario. If you are interested in learning more, you can explore other scenarios with Walrus, **such as provisioning Kubernetes clusters, creating cloud RDS databases, and configuring LB policies.**

If you are interested in Walrus, Welcome to our community:

- Discord: https://discord.gg/fXZUKK2baF
- Twitter/X: https://twitter.com/Seal_io
- LinkedIn: https://www.linkedin.com/company/seal-io
- Youtube: https://www.youtube.com/@Seal-io

If you have any questions about Walrus, please feel free to let me know, I am here to help you :)