Тестирование Pull Request в Kubernetes с GitHub Actions и GKE

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vcluster-pipeline
  labels:
    type: app
    app: vcluster-pipeline
spec:
  replicas: 1
  selector:
    matchLabels:
      app: vcluster-pipeline
  template:
    metadata:
      labels:
        type: app
        app: vcluster-pipeline
    spec:
      containers:
        - name: vcluster-pipeline
          image: ghcr.io/моя-организация/моё-приложение:latest
          envFrom:
            - configMapRef:
                name: postgres-config
      imagePullSecrets:
        - name: github-docker-registry
---
apiVersion: v1
kind: Service
metadata:
  name: vcluster-pipeline
spec:
  type: LoadBalancer
  ports:
    - port: 8080
      targetPort: 8080
  selector:
    app: vcluster-pipeline

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
vcluster-pipeline.yaml
images:
name: ghcr.io/моя-организация/моё-приложение
  newTag: DYNAMIC_TAG

name: Create Docker Registry Secret
  run: |
    kubectl create secret docker-registry github-docker-registry \
      --docker-server=${{ env.REGISTRY }} \
      --docker-email="noreply@github.com" \
      --docker-username="${{ github.actor }}" \
      --docker-password="${{ secrets.GITHUB_TOKEN }}" \
      --dry-run=client -o yaml | kubectl apply -f -

fullnameOverride: postgres
auth:
  user: postgres
  password: root
  postgresPassword: roottoo
primary:
  persistence:
    enabled: false

name: Set config map from values.yaml
  run: |
    kubectl create configmap postgres-config \
      --from-literal="SPRING_FLYWAY_URL=jdbc:postgresql://$(yq .fullnameOverride kubernetes/values.yaml):5432/" \
      --from-literal="SPRING_R2DBC_URL=r2dbc:postgresql://$(yq .fullnameOverride kubernetes/values.yaml):5432/" \
      --from-literal="SPRING_R2DBC_USERNAME=$(yq .auth.user kubernetes/values.yaml)" \
      --from-literal="SPRING_R2DBC_PASSWORD=$(yq .auth.password kubernetes/values.yaml)"

jobs:
  build:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
      id-token: write
    env:
      REGISTRY: ghcr.io
      IMAGE_NAME: ${{ github.repository }}
      DOCKER_BUILD_RECORD_RETENTION_DAYS: 1
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
        
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
        
      - name: Log into registry ${{ env.REGISTRY }}
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
          
      - name: Extract Docker metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
          tags: |
            type=raw,value=${{github.run_id}}
            
      - name: Build and push Docker image
        uses: docker/build-push-action@v6
        with:
          context: .
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          push: true
          cache-from: type=gha
          cache-to: type=gha,mode=max

name: Authenticate on Google Cloud
  uses: google-github-actions/auth@v2
  with:
    workload_identity_provider: projects/123456789/locations/global/workloadIdentityPools/github-actions-pool/providers/github-provider
    service_account: [email]github-actions@ваш-проект.iam.gserviceaccount.com[/email]
 
name: Set GKE credentials
  uses: google-github-actions/get-gke-credentials@v2
  with:
    cluster_name: test-pr-cluster
    location: europe-west3

name: Create namespace for PR
  run: |
    NAMESPACE="pr-${{ github.event.pull_request.number }}"
    kubectl create namespace $NAMESPACE --dry-run=client -o yaml | kubectl apply -f -
    kubectl config set-context --current --namespace=$NAMESPACE
    echo "NAMESPACE=$NAMESPACE" >> $GITHUB_ENV

name: Install PostgreSQL
  run: |
    helm install postgresql oci://registry-1.docker.io/bitnamicharts/postgresql \
    --values kubernetes/values.yaml \
    --namespace ${{ env.NAMESPACE }}
    
name: Wait for PostgreSQL to be ready
  run: |
    kubectl wait --for=condition=ready pod -l app.kubernetes.io/name=postgresql \
    --timeout=120s \
    --namespace ${{ env.NAMESPACE }}

name: Create ConfigMap for application
  run: |
    kubectl create configmap postgres-config \
      --from-literal="SPRING_FLYWAY_URL=jdbc:postgresql://postgresql:5432/" \
      --from-literal="SPRING_R2DBC_URL=r2dbc:postgresql://postgresql:5432/" \
      --from-literal="SPRING_R2DBC_USERNAME=postgres" \
      --from-literal="SPRING_R2DBC_PASSWORD=root" \
      --namespace ${{ env.NAMESPACE }} \
      --dry-run=client -o yaml | kubectl apply -f -

name: Create Docker Registry Secret
  run: |
    kubectl create secret docker-registry github-docker-registry \
      --docker-server=${{ env.REGISTRY }} \
      --docker-email="noreply@github.com" \
      --docker-username="${{ github.actor }}" \
      --docker-password="${{ secrets.GITHUB_TOKEN }}" \
      --namespace ${{ env.NAMESPACE }} \
      --dry-run=client -o yaml | kubectl apply -f -

name: Update image tag in Kustomization
  run: |
    cd kubernetes
    kustomize edit set image ghcr.io/моя-организация/моё-приложение=ghcr.io/моя-организация/моё-приложение:${{ github.run_id }}
    
name: Deploy application
  run: |
    kubectl apply -k kubernetes --namespace ${{ env.NAMESPACE }}
    
name: Wait for application to be ready
  run: |
    kubectl wait --for=condition=ready pod -l app=vcluster-pipeline \
    --timeout=120s \
    --namespace ${{ env.NAMESPACE }}

name: Retrieve LoadBalancer external IP
  run: |
    for i in {1..10}; do
      EXTERNAL_IP=$(kubectl get service vcluster-pipeline -o jsonpath='{.status.loadBalancer.ingress[0].ip}' --namespace ${{ env.NAMESPACE }})
      if [ -n "$EXTERNAL_IP" ]; then
        break
      fi
      echo "Waiting for external IP... Attempt $i of 10"
      sleep 10
    done
    if [ -z "$EXTERNAL_IP" ]; then
      echo "Error: External IP not assigned to the service" >&2
      exit 1
    fi
    APP_BASE_URL="http://${EXTERNAL_IP}:8080"
    echo "APP_BASE_URL=$APP_BASE_URL" >> $GITHUB_ENV
    echo "External IP is $APP_BASE_URL"

name: Run integration tests
  run: |
    export APP_BASE_URL
    ./mvnw -B verify -Dtest=SkipAll -Dit.test=ApplicationIT -Dsurefire.failIfNoSpecifiedTests=false
  env:
    APP_BASE_URL: ${{ env.APP_BASE_URL }}

name: Update PR with test results
  if: always()
  uses: actions/github-script@v6
  with:
    script: |
      const outcome = '${{ job.status }}';
      const url = '${{ env.APP_BASE_URL }}';
      
      let message = '';
      if (outcome === 'success') {
        message = `Интеграционные тесты успешно пройдены\n\nПриложение доступно по адресу: ${url}\n\nЭто окружение будет автоматически удалено через 24 часа.`;
      } else {
        message = `Интеграционные тесты завершились с ошибкой\n\nПриложение доступно по адресу: ${url} для отладки проблемы.\n\nЭто окружение будет автоматически удалено через 24 часа.`;
      }
      
      github.rest.issues.createComment({
        issue_number: context.issue.number,
        owner: context.repo.owner,
        repo: context.repo.repo,
        body: message
      });

name: Schedule cleanup
  if: always()
  run: |
    cat <<EOF | kubectl apply -f -
    apiVersion: batch/v1
    kind: CronJob
    metadata:
      name: cleanup-pr-${{ github.event.pull_request.number }}
      namespace: default
    spec:
      schedule: "0 0 * * *"  # Полночь каждый день
      successfulJobsHistoryLimit: 1
      failedJobsHistoryLimit: 1
      jobTemplate:
        spec:
          template:
            spec:
              serviceAccountName: cleanup-sa
              containers:
              - name: kubectl
                image: bitnami/kubectl
                command:
                - /bin/sh
                - -c
                - kubectl delete namespace ${{ env.NAMESPACE }} || true
              restartPolicy: OnFailure
EOF

name: Debug information
  if: always()
  run: |
    echo "Namespace: ${{ env.NAMESPACE }}"
    echo "App URL: ${{ env.APP_BASE_URL }}"
    kubectl get all --namespace ${{ env.NAMESPACE }}
    kubectl describe pods --namespace ${{ env.NAMESPACE }}
    kubectl logs -l app=vcluster-pipeline --namespace ${{ env.NAMESPACE }} --tail=100

name: Run basic connectivity tests
  run: |
    curl -f ${{ env.APP_BASE_URL }}/health || exit 1
    curl -f ${{ env.APP_BASE_URL }}/api/v1/status || exit 1
    echo "Basic connectivity tests passed"
 
name: Run functional tests
  if: success()
  run: |
    ./mvnw -B verify -Dtest=SkipAll -Dit.test=FunctionalIT -Dsurefire.failIfNoSpecifiedTests=false
  env:
    APP_BASE_URL: ${{ env.APP_BASE_URL }}
 
name: Run load tests
  if: success() && contains(github.event.pull_request.labels.*.name, 'full-test')
  run: |
    ./mvnw -B verify -Dtest=SkipAll -Dit.test=LoadIT -Dsurefire.failIfNoSpecifiedTests=false
  env:
    APP_BASE_URL: ${{ env.APP_BASE_URL }}

name: Deploy current main version
  run: |
    kubectl apply -k kubernetes/stable --namespace ${{ env.NAMESPACE }}
    kubectl wait --for=condition=ready pod -l app=vcluster-pipeline,version=stable --timeout=120s --namespace ${{ env.NAMESPACE }}
 
name: Run baseline tests
  run: |
    ./mvnw -B verify -Dtest=SkipAll -Dit.test=BaselineIT -Dsurefire.failIfNoSpecifiedTests=false
  env:
    APP_BASE_URL: ${{ env.STABLE_APP_URL }}
 
name: Deploy PR version
  run: |
    kubectl apply -k kubernetes/pr --namespace ${{ env.NAMESPACE }}
    kubectl wait --for=condition=ready pod -l app=vcluster-pipeline,version=pr --timeout=120s --namespace ${{ env.NAMESPACE }}
 
name: Run migration tests
  run: |
    ./mvnw -B verify -Dtest=SkipAll -Dit.test=MigrationIT -Dsurefire.failIfNoSpecifiedTests=false
  env:
    STABLE_APP_URL: ${{ env.STABLE_APP_URL }}
    PR_APP_URL: ${{ env.PR_APP_URL }}

name: Check application health
  run: |
    for i in {1..12}; do
      if curl -s -f ${{ env.APP_BASE_URL }}/health > /dev/null; then
        echo "Application is healthy"
        exit 0
      fi
      echo "Waiting for application to become healthy... Attempt $i of 12"
      sleep 10
    done
    echo "Application failed health check, performing rollback"
    kubectl rollout undo deployment/vcluster-pipeline --namespace ${{ env.NAMESPACE }}
    exit 1

name: Run database migrations
  run: |
    kubectl create job --from=cronjob/db-migrate db-migrate-${{ github.run_id }} --namespace ${{ env.NAMESPACE }}
    kubectl wait --for=condition=complete job/db-migrate-${{ github.run_id }} --timeout=180s --namespace ${{ env.NAMESPACE }}

name: Seed database with test data
  run: |
    kubectl exec -i $(kubectl get pod -l app.kubernetes.io/name=postgresql -o jsonpath='{.items[0].metadata.name}' --namespace ${{ env.NAMESPACE }}) -- psql -U postgres -d postgres < ./testdata/seed.sql

name: Create namespace for PR
  run: |
    NAMESPACE="pr-${{ github.event.pull_request.number }}"
    kubectl create namespace $NAMESPACE --dry-run=client -o yaml | kubectl apply -f -
    kubectl config set-context --current --namespace=$NAMESPACE
    echo "NAMESPACE=$NAMESPACE" >> $GITHUB_ENV

name: Create network policy
  run: |
    cat <<EOF | kubectl apply -f -
    apiVersion: networking.k8s.io/v1
    kind: NetworkPolicy
    metadata:
      name: allow-only-internal
      namespace: ${{ env.NAMESPACE }}
    spec:
      podSelector: {}
      policyTypes:
      - Ingress
      - Egress
      ingress:
      - from:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: ${{ env.NAMESPACE }}
      egress:
      - to:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: kube-system
      - to:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: ${{ env.NAMESPACE }}
      - to:
        - ipBlock:
            cidr: 0.0.0.0/0
            except:
            - 10.0.0.0/8
            - 172.16.0.0/12
            - 192.168.0.0/16
    EOF

name: Create resource quota
  run: |
    cat <<EOF | kubectl apply -f -
    apiVersion: v1
    kind: ResourceQuota
    metadata:
      name: pr-quota
      namespace: ${{ env.NAMESPACE }}
    spec:
      hard:
        requests.cpu: "2"
        requests.memory: 2Gi
        limits.cpu: "4"
        limits.memory: 4Gi
    EOF

name: Create cleanup job
  run: |
    cat <<EOF | kubectl apply -f -
    apiVersion: batch/v1
    kind: CronJob
    metadata:
      name: cleanup-old-prs
      namespace: default
    spec:
      schedule: "0 */6 * * *"
      jobTemplate:
        spec:
          template:
            spec:
              containers:
              - name: kubectl
                image: bitnami/kubectl
                command:
                - /bin/sh
                - -c
                - |
                  for ns in \$(kubectl get ns -l created-by=pr-test --output=jsonpath={.items[*].metadata.name}); do
                    age=\$(kubectl get ns \$ns -o go-template="{{.metadata.creationTimestamp}}")
                    now=\$(date -u +%Y-%m-%dT%H:%M:%SZ)
                    age_seconds=\$(( \$(date -d "\$now" +%s) - \$(date -d "\$age" +%s) ))
                    if [ \$age_seconds -gt 86400 ]; then
                      kubectl delete ns \$ns
                    fi
                  done
              restartPolicy: OnFailure
    EOF

name: Cleanup PR Environment
on:
  pull_request:
    types: [closed]
jobs:
  cleanup:
    runs-on: ubuntu-latest
    steps:
      - name: Authenticate with GKE
        uses: google-github-actions/auth@v2
        with:
          workload_identity_provider: projects/123456/locations/global/workloadIdentityPools/github-actions/providers/github
          service_account: [email]github-actions@project.iam.gserviceaccount.com[/email]
      
      - name: Get GKE credentials
        uses: google-github-actions/get-gke-credentials@v2
        with:
          cluster_name: test-pr-cluster
          location: europe-west3
          
      - name: Delete namespace
        run: kubectl delete namespace pr-${{ github.event.pull_request.number }} --ignore-not-found

name: Collect application logs
if: always()
run: |
  mkdir -p logs
  kubectl logs -l app=vcluster-pipeline --namespace ${{ env.NAMESPACE }} > logs/app.log || true
  kubectl logs -l app.kubernetes.io/name=postgresql --namespace ${{ env.NAMESPACE }} > logs/db.log || true
  
name: Collect pod events
if: always()
run: |
  kubectl get events --namespace ${{ env.NAMESPACE }} > logs/events.log || true
  
name: Upload logs as artifacts
if: always()
uses: actions/upload-artifact@v3
with:
  name: kubernetes-logs
  path: logs/
  retention-days: 5

name: Collect resource metrics
if: always()
run: |
  kubectl top pods --namespace ${{ env.NAMESPACE }} > logs/resource_usage.log
  kubectl get pods -o wide --namespace ${{ env.NAMESPACE }} > logs/pods.log

name: Run performance test
run: |
  cat > performance.js <<EOF
  import http from 'k6/http';
  import { check, sleep } from 'k6';
  
  export default function() {
    const res = http.get('${{ env.APP_BASE_URL }}/api/v1/items');
    check(res, {
      'status is 200': (r) => r.status === 200,
      'response time < 200ms': (r) => r.timings.duration < 200
    });
    sleep(1);
  }
  EOF
  
  docker run --rm -v $(pwd):/scripts loadimpact/k6 run \
    --summary-export=logs/performance.json \
    /scripts/performance.js

name: Compare performance with baseline
run: |
  PR_P95=$(cat logs/performance.json | jq '.metrics.http_req_duration.values."p(95)"')
  BASELINE_P95=$(cat baseline_metrics.json | jq '.metrics.http_req_duration.values."p(95)"')
  
  if (( $(echo "$PR_P95 > $BASELINE_P95 * 1.2" | bc -l) )); then
    echo "Performance degradation detected! P95 response time increased by more than 20%."
    echo "PR: $PR_P95 ms, Baseline: $BASELINE_P95 ms"
    echo "::warning::Performance degradation detected"
  else
    echo "Performance is within acceptable range"
  fi

name: Report test results to PR
if: always()
uses: actions/github-script@v6
with:
  script: |
    const testResults = require('./test-results.json');
    
    const summary = {
      passed: testResults.filter(t => t.status === 'passed').length,
      failed: testResults.filter(t => t.status === 'failed').length,
      skipped: testResults.filter(t => t.status === 'skipped').length
    };
    
    const details = testResults
      .filter(t => t.status === 'failed')
      .map(t => `- ${t.name}: ${t.message}`)
      .join('\n');
    
    const conclusion = summary.failed > 0 ? 'failure' : 'success';
    
    await github.rest.checks.create({
      owner: context.repo.owner,
      repo: context.repo.repo,
      name: 'Integration Tests',
      head_sha: context.payload.pull_request.head.sha,
      status: 'completed',
      conclusion: conclusion,
      output: {
        title: `Tests: ${summary.passed} passed, ${summary.failed} failed, ${summary.skipped} skipped`,
        summary: [INLINE]### Test Results\n\n${details}[/INLINE],
        text: JSON.stringify(testResults, null, 2)
      }
    });

name: Generate code coverage report
run: |
  ./mvnw jacoco:report
  
name: Comment PR with coverage report
uses: actions/github-script@v6
with:
  script: |
    const fs = require('fs');
    const coverageData = JSON.parse(fs.readFileSync('./target/site/jacoco/jacoco.json', 'utf8'));
    
    const coverage = {
      instructions: coverageData.counters.find(c => c.type === 'INSTRUCTION').covered / coverageData.counters.find(c => c.type === 'INSTRUCTION').total * 100,
      branches: coverageData.counters.find(c => c.type === 'BRANCH').covered / coverageData.counters.find(c => c.type === 'BRANCH').total * 100,
      lines: coverageData.counters.find(c => c.type === 'LINE').covered / coverageData.counters.find(c => c.type === 'LINE').total * 100
    };
    
    const comment = `## Code Coverage Report
 
| Type | Coverage |
|------|----------|
| Instructions | ${coverage.instructions.toFixed(2)}% |
| Branches | ${coverage.branches.toFixed(2)}% |
| Lines | ${coverage.lines.toFixed(2)}% |
 
[View detailed report](${process.env.GITHUB_SERVER_URL}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId})`;
    
    github.rest.issues.createComment({
      issue_number: context.issue.number,
      owner: context.repo.owner,
      repo: context.repo.repo,
      body: comment
    });

name: Run profiling
if: contains(github.event.pull_request.labels.*.name, 'profile')
run: |
  # Получаем PID Java-процесса
  POD_NAME=$(kubectl get pods -l app=vcluster-pipeline -o jsonpath='{.items[0].metadata.name}' --namespace ${{ env.NAMESPACE }})
  JAVA_PID=$(kubectl exec $POD_NAME --namespace ${{ env.NAMESPACE }} -- jps | grep -v Jps | cut -d ' ' -f 1)
  
  # Запускаем профилирование на 30 секунд
  kubectl exec $POD_NAME --namespace ${{ env.NAMESPACE }} -- \
    /opt/async-profiler/profiler.sh -d 30 -f /tmp/profile.html $JAVA_PID
  
  # Копируем результаты профилирования
  kubectl cp ${{ env.NAMESPACE }}/$POD_NAME:/tmp/profile.html ./logs/profile.html
  
name: Upload profile as artifact
if: contains(github.event.pull_request.labels.*.name, 'profile')
uses: actions/upload-artifact@v3
with:
  name: performance-profile
  path: logs/profile.html
  retention-days: 5

name: Send Slack notification
if: always()
uses: slackapi/slack-github-action@v1.24.0
with:
  payload: |
    {
      "text": "Integration Test Results for PR #${{ github.event.pull_request.number }}",
      "blocks": [
        {
          "type": "section",
          "text": {
            "type": "mrkdwn",
            "text": "*PR #${{ github.event.pull_request.number }}: ${{ github.event.pull_request.title }}*\n${{ job.status == 'success' && 'Tests passed' || 'Tests failed' }}"
          }
        },
        {
          "type": "section",
          "text": {
            "type": "mrkdwn",
            "text": "View PR: ${{ github.event.pull_request.html_url }}\nView workflow: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
          }
        }
      ]
    }
env:
  SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK }}
  SLACK_WEBHOOK_TYPE: INCOMING_WEBHOOK

name: Set up Docker Buildx
  uses: docker/setup-buildx-action@v3
 
name: Build and push Docker image
  uses: docker/build-push-action@v6
  with:
    context: .
    tags: ${{ steps.meta.outputs.tags }}
    push: true
    cache-from: type=gha                             # Использование кэша GitHub Actions
    cache-to: type=gha,mode=max

name: Cache Maven packages
  uses: actions/cache@v3
  with:
    path: ~/.m2
    key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
    restore-keys: ${{ runner.os }}-m2

# Стадия сборки
FROM maven:3.8.4-openjdk-17 AS build
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn package -DskipTests
 
# Финальный образ
FROM openjdk:17-slim
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

name: Warm up cluster
  run: |
    # Предварительно скачиваем популярные образы
    kubectl create job warm-up-job --image=busybox -- echo "Warming up" || true
    kubectl create job postgres-preload --image=postgres:15 -- echo "Preloading postgres" || true
    
    # Создаем пулы подов для часто используемых компонентов
    kubectl apply -f - <<EOF
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: postgres-pool
      namespace: default
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: postgres-pool
      template:
        metadata:
          labels:
            app: postgres-pool
        spec:
          containers:
          - name: postgres
            image: postgres:15
            resources:
              requests:
                cpu: 100m
                memory: 200Mi
            command: ["sleep", "infinity"]
    EOF

name: Set TTL for resources
  run: |
    kubectl annotate namespace ${{ env.NAMESPACE }} janitor/ttl=24h

name: Cleanup PR Environment
on:
  pull_request:
    types: [closed]
jobs:
  cleanup:
    runs-on: ubuntu-latest
    steps:
      - name: Delete namespace
        run: kubectl delete namespace pr-${{ github.event.pull_request.number }} --ignore-not-found

name: Cleanup orphaned resources
  run: |
    # Находим PR, которые уже закрыты, но их среды остались
    for ns in $(kubectl get ns -l created-by=pr-test --output=jsonpath={.items[*].metadata.name}); do
      PR_NUMBER=$(echo $ns | sed 's/pr-//')
      # Проверяем, существует ли еще PR
      if ! gh pr view $PR_NUMBER &> /dev/null; then
        kubectl delete ns $ns
      fi
    done
  env:
    GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

name: Install Istio
  run: |
    curl -L [url]https://istio.io/downloadIstio[/url] | ISTIO_VERSION=1.18.2 sh -
    ./istio-1.18.2/bin/istioctl install --set profile=demo -y
    kubectl label namespace ${{ env.NAMESPACE }} istio-injection=enabled

name: Configure traffic routing
  run: |
    cat <<EOF | kubectl apply -f -
    apiVersion: networking.istio.io/v1alpha3
    kind: VirtualService
    metadata:
      name: my-app-vs
      namespace: ${{ env.NAMESPACE }}
    spec:
      hosts:
      - "myapp.example.com"
      gateways:
      - my-gateway
      http:
      - match:
        - uri:
            prefix: /api/v1
        route:
        - destination:
            host: vcluster-pipeline
            port:
              number: 8080
    EOF

name: Setup fault injection
  run: |
    cat <<EOF | kubectl apply -f -
    apiVersion: networking.istio.io/v1alpha3
    kind: VirtualService
    metadata:
      name: fault-injection
      namespace: ${{ env.NAMESPACE }}
    spec:
      hosts:
      - postgresql
      http:
      - fault:
          delay:
            percentage:
              value: 50
            fixedDelay: 5s
        route:
        - destination:
            host: postgresql
    EOF