CI/CD Automation Scripts

The helixml/helix project currently does not have a fully established CI/CD automation setup. However, there are scripts and configurations within the project that can aid in creating an automated CI/CD pipeline. Below is a step-by-step guide on how CI/CD could be automated using the available elements within the project, along with code examples.

Step 1: Dockerfile Configuration

The project includes a Dockerfile that automates the build process for both the backend (Golang) and frontend (Node.js). This Dockerfile can be utilized in CI/CD pipelines to create and deploy images efficiently.

# Backend build
FROM golang:1.22 AS go-build-env
WORKDIR /app

COPY go.mod .
COPY go.sum .

RUN go mod download

COPY api ./api
COPY .git /.git

WORKDIR /app/api

RUN CGO_ENABLED=0 go build -ldflags "-s -w" -o /helix

# Frontend build
FROM node:21-alpine AS ui-build-env

WORKDIR /app

RUN echo "installing apk packages" && \
  apk update && \
  apk upgrade && \
  apk add \
    bash \
    git \
    curl \
    openssh

COPY ./frontend/*.json /app/
COPY ./frontend/yarn.lock /app/yarn.lock

RUN yarn install

COPY ./frontend /app

RUN yarn build

FROM alpine:3.17
RUN apk --update add ca-certificates

COPY --from=go-build-env /helix /helix
COPY --from=ui-build-env /app/dist /www

ENV FRONTEND_URL=/www

ENTRYPOINT ["/helix", "serve"]

Step 2: Implementing CI/CD with Scripts

Scripts located in the scripts/ directory can facilitate different parts of the CI/CD process. Here are some notable scripts:

2.1 Build and Push Script

The build-and-push.sh script could be designed to build the Docker images and push them to a container registry.

Example of build-and-push.sh:

#!/bin/bash

# Build Docker images
docker build -t helix:latest .

# Push Docker images to the registry
docker tag helix:latest your-registry/helix:latest
docker push your-registry/helix:latest

2.2 Continuous Deployment with cloudbuild.yaml

The presence of cloudbuild.yaml indicates potential integration with Google Cloud Build for automating deployments. A sample continuous deployment configuration might look like this:

steps:
  - name: 'gcr.io/cloud-builders/docker'
    args: ['build', '-t', 'gcr.io/$PROJECT_ID/helix', '.']
  
  - name: 'gcr.io/cloud-builders/docker'
    args: ['push', 'gcr.io/$PROJECT_ID/helix']

  - name: 'gcr.io/cloud-builders/gcloud'
    args: ['run', 'deploy', 'helix', '--image', 'gcr.io/$PROJECT_ID/helix', '--platform', 'managed']

Step 3: Setting Up Monitoring and CI/CD Triggers

Implementing monitoring and CI/CD triggers would enhance the automation process. Example configurations could be set up in .drone.yml to incorporate CI processes such as running tests whenever changes are made.

Example .drone.yml File

kind: pipeline
name: default

steps:
  - name: build
    image: golang:1.22
    commands:
      - go build -o helix ./api/main.go
  
  - name: test
    image: golang:1.22
    commands:
      - go test ./...

  - name: docker
    image: plugins/docker
    settings:
      repo: your-repo/helix
      tags: latest

Next Steps

1. Evaluate the CI/CD Tools: Depending on requirements, evaluate CI/CD tools such as GitHub Actions, GitLab CI/CD, CircleCI, etc.

2. Integration with Kubernetes: Explore integrating the helix project with Kubernetes for better orchestration and scaling.

3. Enhance Testing Framework: Develop a more robust testing strategy to cover unit, integration, and end-to-end tests.

4. Documentation and Best Practices: Develop concise documentation related to setting up CI/CD processes to assist future developers.

5. Feedback Loop: Establish a feedback loop by integrating monitoring tools to observe deployments and application performance.

The above steps and examples provide a pathway towards creating a comprehensive CI/CD setup, utilizing existing scripts, and configurations within the helixml/helix project.

Source: Project directory structure and configuration files observed.