image_run_v3.yml

name: Image Creation Run

on:

  schedule:
  - cron: '0 * * * *'

  workflow_dispatch:

permissions: read-all

jobs:
  airflow:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run airflow/airflow/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/airflow": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  airflow-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run airflow/airflow/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/airflow-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  apache:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run apache/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/apache": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  apache-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run apache/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/apache2-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  apache-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run apache/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/apache-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  cassandra-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run cassandra/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/cassandra-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  consul:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run consul/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/consul": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  consul-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run consul/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/consul-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  consul-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run consul/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/consul-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  couchdb:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run couchdb/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/couchdb": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  couchdb-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run couchdb/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/couchdb_3-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  couchdb-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run couchdb/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/couchdb-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  curl:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run curl/curlimages --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/curl": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  elasticsearch:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run elasticsearch/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/elasticsearch": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  elasticsearch-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run elasticsearch/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/elasticsearch-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  envoy:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run envoy/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/envoy": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  envoy-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run envoy/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/envoy-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  etcd:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run etcd/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/etcd": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  etcd-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run etcd/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/etcd-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  fluent-bit:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run fluent-bit/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/fluent-bit": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  fluent-bit-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run fluent-bit/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/fluent-bit-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  fluentd:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run fluentd/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/fluentd": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  fluentd-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run fluentd/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/fluentd-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  fluentd-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run fluentd/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/fluentd-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  ghost:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run ghost/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/ghost": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  grafana-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run grafana/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/grafana-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  haproxy:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run haproxy/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/haproxy": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  haproxy-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run haproxy/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/haproxy24-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  haproxy-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run haproxy/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/haproxy-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  influxdb:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run influxdb/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/influxdb": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  keycloak-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run keycloak/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/keycloak-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  kong:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run kong/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/kong": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  mariadb:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run mariadb/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/mariadb": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  mariadb-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run mariadb/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/mariadb-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  mariadb-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run mariadb/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/mariadb-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  memcached:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run memcached/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/memcached": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  memcached-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run memcached/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/memcached-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  memcached-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run memcached/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/memcached-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  microsoft-sql-server-2019-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run microsoft-sql-server-2019/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/microsoft-sql-server-2019-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  mongodb:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run mongodb/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/mongodb": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  mongodb-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run mongodb/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/mongodb-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  mongodb-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run mongodb/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/mongodb-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  moodle-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run moodle/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/moodle-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  mysql:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run mysql/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/mysql": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  mysql-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run mysql/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/mysql8-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  mysql-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run mysql/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/mysql-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  nats:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run nats/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/nats": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  nats-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run nats/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/nats-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  nats-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run nats/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/nats-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  nginx:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run nginx/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/nginx": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  nginx-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run nginx/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/nginx-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  nginx-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run nginx/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/nginx-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  nifi-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run nifi/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/nifi-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  node-exporter:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run node-exporter/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/node-exporter": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  node-exporter-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run node-exporter/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/node-exporter-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  oncall:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run oncall/grafana --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/oncall": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  postgresql:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run postgresql/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/postgresql": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  postgresql-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run postgresql/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/postgresql12-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  postgresql-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run postgresql/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/postgresql-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  prometheus:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run prometheus/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/prometheus": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  prometheus-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run prometheus/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/prometheus-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  rabbitmq:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run rabbitmq/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/rabbitmq": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  redis:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run redis/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/redis": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  redis-cluster:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run redis-cluster/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/redis-cluster": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  redis-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run redis/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/redis6-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  redis-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run redis/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/redis-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  telegraf:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run telegraf/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/telegraf": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  traefik:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run traefik/traefik --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/traefik": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  traefik-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run traefik/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/traefik-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  vault:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run vault/hashicorp --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/vault": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  wordpress:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run wordpress/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/wordpress": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  wordpress-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run wordpress/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/wordpress-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  yourls:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run yourls/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/yourls": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  zookeeper:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run zookeeper/bitnami --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/zookeeper": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  zookeeper-ib:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run zookeeper/ironbank --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/zookeeper-ib": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls
  zookeeper-official:
    runs-on: ubuntu-latest

    environment: actions-cicd

    steps:
      - uses: actions/checkout@v4


      - name: Start minikube

        with:
          memory: 6g
        uses: medyagh/setup-minikube@master
      - name: Check k8s cluster !

        run: kubectl get pods -A
      - name: Setup ubuntu
        env:
          RF_ACCESS_ID: ${{ secrets.RF_ACCESS_ID }}
          RF_SECRET_ACCESS_KEY: ${{ secrets.RF_SECRET_ACCESS_KEY }}
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RF_PLATFORM_HOST: ${{ secrets.RF_PLATFORM_HOST }}
          RF_APP_HOST: ${{ secrets.RF_APP_HOST }}

        run: ./scripts/setup.sh

      - name: Set RF CLI Path
        run: echo "/usr/local/rapidfort_cli" >> $GITHUB_PATH


      - name: Create images and publish to dockerhub
        env:
          DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
          DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
          RAPIDFORT_ACCOUNT: ${{ secrets.RAPIDFORT_ACCOUNT }}
          IB_DOCKER_USERNAME: ${{ secrets.IB_DOCKER_USERNAME }}
          IB_DOCKER_PASSWORD: ${{ secrets.IB_DOCKER_PASSWORD }}
        if: github.event_name != 'pull_request'
        run: python3 community_images/common/orchestrator/main.py hourly_run zookeeper/official --publish


      - name: Report pulls
        env:
          PULL_COUNTER_MAGIC_TOKEN: ${{ secrets.PULL_COUNTER_MAGIC_TOKEN }}

        run: |
          curl -X POST \
           -H "Accept: application/json" \
           -H "Authorization: Bearer ${PULL_COUNTER_MAGIC_TOKEN}" \
           -d '{ "rapidfort/zookeeper-official": 1 }' \
           https://data-receiver.rapidfort.com/counts/internal_image_pulls