pipeline-actions/deploy-restart/action.yaml

name: Deploy Restart (kubectl rollout)
description: Validate KUBE_CONFIG, install kubectl, and perform a rollout restart of a Kubernetes deployment.

inputs:
  kube_config:
    description: Full kubeconfig YAML content (pass via secrets)
    required: true
  deployment_name:
    description: Name of the Kubernetes Deployment to restart
    required: true
  namespace:
    description: Kubernetes namespace of the deployment
    required: false
    default: default
  kube_version:
    description: Kubernetes version to download (stable, or a specific version like v1.31.0)
    required: false
    default: stable
  wait:
    description: Wait for the rollout to finish and fail the step if it does not become ready ("true"/"false")
    required: false
    default: "true"
  timeout:
    description: How long to wait for the rollout when wait is enabled (kubectl duration, e.g. 300s, 5m)
    required: false
    default: 300s

runs:
  using: composite
  steps:
    - name: Check KUBE_CONFIG validity
      shell: bash
      env:
        KUBE_CONFIG: ${{ inputs.kube_config }}
      run: |
        if [ -z "${KUBE_CONFIG}" ] || [ "${KUBE_CONFIG}" = "" ] || [ "${KUBE_CONFIG// }" = "" ]; then
          echo "KUBE_CONFIG is not set or is empty."
          exit 1
        fi

    - name: Check out repository
      uses: actions/checkout@v4

    - name: Download and install kubectl
      shell: bash
      env:
        KUBE_VERSION: ${{ inputs.kube_version }}
      run: |
        # strip stray CR (CRLF checkout via core.autocrlf)
        KUBE_VERSION=$(printf '%s' "${KUBE_VERSION}" | tr -d '\r')

        # 1. Check if kubectl is already pre-installed and meets version requirements
        if command -v kubectl &> /dev/null; then
          INSTALLED_VER=$(kubectl version --client --output=json 2>/dev/null | grep -oE '"gitVersion": "[^"]+"' | cut -d'"' -f4)
          if [ -z "${INSTALLED_VER}" ]; then
            INSTALLED_VER=$(kubectl version --client 2>/dev/null | grep -oE 'v[0-9]+\.[0-9]+\.[0-9]+')
          fi
          echo "Found pre-installed kubectl version: ${INSTALLED_VER}"
          
          # If stable or version matches, reuse pre-installed kubectl
          if [ "${KUBE_VERSION}" = "stable" ] || [ "${INSTALLED_VER}" = "${KUBE_VERSION}" ]; then
            echo "Using pre-installed kubectl."
            exit 0
          fi
        fi

        # 2. Check/install curl if missing
        if ! command -v curl &> /dev/null; then
          echo "curl not found, attempting to install..."
          if command -v apt-get &> /dev/null; then
            apt-get update -y && apt-get install -y curl
          elif command -v apk &> /dev/null; then
            apk add --no-cache curl
          elif command -v dnf &> /dev/null; then
            dnf install -y curl
          elif command -v yum &> /dev/null; then
            yum install -y curl
          else
            echo "::error::curl is missing and no supported package manager (apt-get, apk, dnf, yum) was found."
            exit 1
          fi
        fi

        # 3. Resolve version
        if [ "${KUBE_VERSION}" = "stable" ]; then
          KUBE_VER="$(curl -L -s https://dl.k8s.io/release/stable.txt)"
        else
          KUBE_VER="${KUBE_VERSION}"
        fi

        # 4. Detect runner architecture and download the matching kubectl
        case "$(uname -m)" in
          x86_64|amd64)   KUBE_ARCH=amd64 ;;
          aarch64|arm64)  KUBE_ARCH=arm64 ;;
          armv7l|armv7)   KUBE_ARCH=arm ;;
          *)
            echo "::error::Unsupported runner architecture: $(uname -m)"
            exit 1
            ;;
        esac
        echo "Downloading kubectl version ${KUBE_VER} (linux/${KUBE_ARCH})..."
        curl -fLO "https://dl.k8s.io/release/${KUBE_VER}/bin/linux/${KUBE_ARCH}/kubectl"

        # 5. Install kubectl to a writable directory
        if [ -w "/usr/local/bin" ]; then
          install -m 0755 kubectl /usr/local/bin/kubectl
          echo "Installed kubectl to /usr/local/bin"
        else
          echo "/usr/local/bin is not writable. Installing locally and updating PATH..."
          LOCAL_BIN="${HOME}/.local/bin"
          mkdir -p "${LOCAL_BIN}"
          install -m 0755 kubectl "${LOCAL_BIN}/kubectl"
          echo "${LOCAL_BIN}" >> "$GITHUB_PATH"
          export PATH="${LOCAL_BIN}:${PATH}"
          echo "Installed kubectl to ${LOCAL_BIN}"
        fi

        kubectl version --client

    - name: Set up kubeconfig
      shell: bash
      env:
        KUBE_CONFIG: ${{ inputs.kube_config }}
      run: |
        # strip stray CR (CRLF checkout via core.autocrlf)
        printf '%s' "${KUBE_CONFIG}" | tr -d '\r' > kubeconfig.yaml
        kubectl --kubeconfig=kubeconfig.yaml cluster-info

    - name: Rollout restart
      shell: bash
      env:
        DEPLOYMENT_NAME: ${{ inputs.deployment_name }}
        NAMESPACE: ${{ inputs.namespace }}
      run: |
        kubectl --kubeconfig=kubeconfig.yaml rollout restart \
          deployment "${DEPLOYMENT_NAME}" -n "${NAMESPACE}"

    - name: Wait for rollout to complete
      shell: bash
      env:
        DEPLOYMENT_NAME: ${{ inputs.deployment_name }}
        NAMESPACE: ${{ inputs.namespace }}
        WAIT: ${{ inputs.wait }}
        TIMEOUT: ${{ inputs.timeout }}
      run: |
        # strip stray CR (CRLF checkout via core.autocrlf)
        WAIT=$(printf '%s' "${WAIT}" | tr -d '\r' | tr '[:upper:]' '[:lower:]')
        TIMEOUT=$(printf '%s' "${TIMEOUT}" | tr -d '\r')

        if [ "${WAIT}" != "true" ]; then
          echo "wait=${WAIT}; not waiting for rollout."
          exit 0
        fi

        echo "Waiting up to ${TIMEOUT} for deployment/${DEPLOYMENT_NAME} in ${NAMESPACE}..."
        if kubectl --kubeconfig=kubeconfig.yaml rollout status \
             deployment "${DEPLOYMENT_NAME}" -n "${NAMESPACE}" --timeout="${TIMEOUT}"; then
          echo "Rollout of deployment/${DEPLOYMENT_NAME} completed."
          exit 0
        fi

        echo "::error::Rollout of deployment/${DEPLOYMENT_NAME} did not complete within ${TIMEOUT}."
        echo "== deployment =="
        kubectl --kubeconfig=kubeconfig.yaml describe deployment "${DEPLOYMENT_NAME}" -n "${NAMESPACE}" | tail -n 30 || true
        echo "== pods =="
        kubectl --kubeconfig=kubeconfig.yaml get pods -n "${NAMESPACE}" -o wide || true
        echo "== recent events =="
        kubectl --kubeconfig=kubeconfig.yaml get events -n "${NAMESPACE}" \
          --sort-by=.lastTimestamp | tail -n 20 || true
        exit 1