- id: deploy
        uses: google-github-actions/deploy-cloudrun@main
        with:
          vpc: us-east1

name: Deployment

on:
  workflow_dispatch:
    inputs:
        version:
          description: 'The version to deploy'
          required: true

env:
  PROJECT_ID: XXXX # ${{ secrets.GCP_PROJECT }}
  GAR_LOCATION: australia-southeast1 # TODO: update region of the Artifact Registry
  REPOSITORY: automation # TODO: update to Artifact Registry docker repository
  IMAGE: automation-template

permissions:
    contents: 'read'
    id-token: 'write'

jobs:
  deployment:
    name: Deployment
    runs-on: ubuntu-latest
    environment: production

    steps:
      - uses: actions/checkout@v2
      - id: auth
        name: 'Authenticate to Google Cloud'
        uses: 'google-github-actions/auth@v0'
        with:
          token_format: 'access_token'
          workload_identity_provider: 'projects/741041240XXX/locations/global/workloadIdentityPools/github-action-pool3/providers/github-action-provider3'
          service_account: '[email protected]'

      - name: Docker configuration
        run: |-
          echo ${{steps.auth.outputs.access_token}} | docker login -u oauth2accesstoken --password-stdin https://$GAR_LOCATION-docker.pkg.dev

      - name: Build
        run: |-
          docker build \
            --tag "$GAR_LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE:$GITHUB_SHA" \
            --build-arg GITHUB_SHA="$GITHUB_SHA" \
            --build-arg GITHUB_REF="$GITHUB_REF" \
            .

      - name: Run Tests
        run: |-
          docker run "$GAR_LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE:$GITHUB_SHA" pytest tests

      # Push the Docker image to Google Artifact Registry
      - name: Publish
        run: |-
          docker push "$GAR_LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE:$GITHUB_SHA"

      - name: 'Deploy to Cloud Run'
        # You may pin to the exact commit or the version.
        # uses: google-github-actions/deploy-cloudrun@ff8b38330cf81843db9cff366e335c34aa467c44
        uses: google-github-actions/deploy-cloudrun@main
        with:
          # Name of the container image to deploy (e.g. gcr.io/cloudrun/hello:latest).
          # Required if not using a service YAML.
          image: $GAR_LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE:$GITHUB_SHA
          # ID of the service or fully qualified identifier for the service.
          # Required if not using a service YAML.
          service: automation-dummy-api
          # Region in which the resource can be found.
          region: $GAR_LOCATION
          # List of key-value pairs to set as environment variables in the format:
          # KEY1=VALUE1,KEY2=VALUE2. All existing environment variables will be
          # removed first.
          # env_vars: # optional
          # YAML serivce description for the Cloud Run service.
          # metadata: # optional
          # The GCP project ID. Overrides project ID set by credentials.
          # project_id: # optional

- id: auth
   name: Authenticate to Google Cloud
   uses: google-github-actions/[email protected]
   with:
       create_credentials_file: true
       workload_identity_provider: ...
       service_account: ${{ secrets.SERVICE_ACCOUNT_EMAIL }}

- name: 🚀 Create cloud run revision
        uses: google-github-actions/deploy-cloudrun@main
        with:
          metadata: "./src/cloud-run-deployment.yml"
          credentials_file_path: ${{ steps.auth.output.credentials_file_path }}

      - name: Deploy to Cloud Run
        uses: google-github-actions/deploy-cloudrun@main
        with:
          service: my-service
          image: gcr.io/my-project/my-service:${{ steps.get_version.outputs.VERSION }}
          credentials: ${{ secrets.GCP_SA_KEY }}
          region: us-east4

name: test_cr

on:
  push:
    branches:
    - '*'
  pull_request:
    branches: [ main ]

jobs:
  deploycr:
   runs-on: 'ubuntu-latest'
   permissions:
      contents: 'read'
      id-token: 'write'
   steps:
    - id: 'auth'
      name: 'Authenticate to Google Cloud'
      uses: 'google-github-actions/[email protected]'
      with:
        workload_identity_provider: '...'
        service_account: '...'
    - name: Deploy to Cloud Run
      id: deploy
      uses: google-github-actions/deploy-cloudrun@main
      with:
        service: hello-cloud-run 
        image: gcr.io/cloudrun/hello

 - name: Deploy to Cloud Run
   id: deploy
  uses: google-github-actions/[email protected]
  with:
    service: my-awesome-service
    image: ...
    env_vars: MY_VAR1=10,MY_VAR2=HELLO,...,MY_VAR_100=WORLD
    env_vars_file: easier_place_to_keep_vars.env

flags: '--args "--database-host=xxx.xxx.xxx.xx" --args "--database-name=bar" --args baz

name: Deployment

on:
  push:
    branches: [main]

env:
  PROJECT_ID: ${{ secrets.GCP_PROJECT }}
  REGION: europe-west4
  IMAGE_NAME: backend
  VERSION: staging
  BUILD_CACHE: /tmp/.buildx-cache

jobs:
  deploy-backend:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v1

      - name: Cache Docker layers
        uses: actions/cache@v2
        with:
          path: ${{ env.BUILD_CACHE }}
          key: ${{ runner.os }}-buildx-${{ hashFiles('./build/Dockerfile') }}
          restore-keys: ${{ runner.os }}-buildx-

      - uses: actions/[email protected]
        with:
          go-version: "1.16.2"
      - run: make test
      - run: make vet

      - name: Setup Cloud SDK
        uses: google-github-actions/[email protected]
        with:
          project_id: ${{ env.PROJECT_ID }}
          service_account_key: ${{ secrets.GCP_CLOUD_RUN_SA_KEY }}
          export_default_credentials: true

      - name: Login to GCR
        uses: docker/login-action@v1
        with:
          registry: gcr.io
          username: _json_key
          password: ${{ secrets.GCP_CLOUD_RUN_SA_KEY }}

      - name: Build and Push Docker image | build-image
        uses: docker/build-push-action@v2
        with:
          file: ./build/Dockerfile
          context: .
          target: build-image
          tags: gcr.io/${{ env.PROJECT_ID }}/${{ env.IMAGE_NAME }}:${{ env.VERSION }}
          cache-from: type=local,src=${{ env.BUILD_CACHE }}
          cache-to: type=local,dest=${{ env.BUILD_CACHE }}-new

      - name: Build and Push Docker image | deploy-image
        uses: docker/build-push-action@v2
        with:
          file: ./build/Dockerfile
          context: .
          target: deploy-image
          push: true
          tags: gcr.io/${{ env.PROJECT_ID }}/${{ env.IMAGE_NAME }}:${{ env.VERSION }}
          cache-from: type=local,src=${{ env.BUILD_CACHE }}
          cache-to: type=local,dest=${{ env.BUILD_CACHE }}-new

      - # Temp fix
        # https://github.com/docker/build-push-action/issues/252
        # https://github.com/moby/buildkit/issues/1896
        name: Move cache
        run: |
          rm -rf ${{ env.BUILD_CACHE }}
          mv ${{ env.BUILD_CACHE }}-new ${{ env.BUILD_CACHE }}

      - name: Deploy private API to Cloud Run
        id: deploy-private
        uses: google-github-actions/deploy-cloudrun@main
        with:
          service: ${{ env.VERSION }}-private-api
          image: gcr.io/${{ env.PROJECT_ID }}/${{ env.IMAGE_NAME }}:${{ env.VERSION }}
          region: ${{ env.REGION }}
          flags: '--service-account=foo --args "--database-host=xxx.xxx.xxx.xx" --args "--database-name=bar" --args "--database-password=secret" --args "--database-user=me" --args private'

      - name: Output private API url
        run: curl "${{ steps.deploy-private.outputs.url }}"

spec:
  template:
    spec:
      containers:
      - image: gcr.io/...
        volumeMounts:
        - name: secretname-gic-tar-haq
          readOnly: true
          mountPath: /secret
      volumes:
      - name:  secretname-gic-tar-haq
        secret:
          secretName: secretname
          items:
          - key: '1'
            path: 1.txt
          - key: '1'
            path: 2.txt

name: Build and Deploy to Cloud Run

on:
  push:
    branches:
      - main

env:
  PROJECT_ID: ${{ secrets.GCP_PROJECT }}
  SERVICE: ropescore-api
  REGION: europe-west1

jobs:
  setup-build-publish-deploy:
    name: Setup, Build, Publish, and Deploy
    runs-on: ubuntu-latest
    environment: production

    steps:
    - name: Checkout
      uses: actions/checkout@v2

    # Setup gcloud CLI
    - uses: google-github-actions/[email protected]
      with:
        service_account_key: ${{ secrets.GCP_SERVICE_ACCOUNT }}
        project_id: ${{ secrets.GCP_PROJECT }}
        export_default_credentials: true

    # Configure Docker to use the gcloud command-line tool as a credential
    # helper for authentication
    - name: Authorize Docker push
      run: gcloud auth configure-docker

    # Build the Docker image
    - name: Build
      run: |-
        docker build \
          --tag "gcr.io/$PROJECT_ID/$SERVICE:$GITHUB_SHA" \
          --build-arg GITHUB_SHA="$GITHUB_SHA" \
          --build-arg GITHUB_REF="$GITHUB_REF" \
          .

    # Push the Docker image to Google Container Registry
    - name: Publish
      run: |-
        docker push "gcr.io/$PROJECT_ID/$SERVICE:$GITHUB_SHA"

    - name: Deploy to Cloud Run
      id: deploy
      uses: google-github-actions/[email protected]
      with:
        service: ${{ env.SERVICE }}
        image: gcr.io/${{ env.PROJECT_ID }}/${{ env.SERVICE }}:${{ github.sha }}
        region: ${{ env.REGION }}
        env_vars: SENTRY_DSN=${{ secrets.SENTRY_DSN }},GCP_PROJECT=${{ secrets.GCP_PROJECT }},JWT_ALG=ES256,JWT_PRIVKEY_PATH=${{ secrets.JWT_PRIVKEY_PATH }},JWT_PUBKEY_PATH=${{ secrets.JWT_PUBKEY_PATH }}
        secrets: ${{ secrets.JWT_PRIVKEY_PATH }}=${{ secrets.JWT_PRIVKEY_SECRET }},${{ secrets.JWT_PUBKEY_PATH }}=${{ secrets.JWT_PUBKEY_SECRET }}
        flags: --max-instances=1

    - name: Show Output
      run: echo ${{ steps.deploy.outputs.url }}

- name: deploy to Cloud Run
  id: deploy
    uses: google-github-actions/[email protected]
    with:
      service: xyz-service
      image: gcr.io/x/y:z
      region: us-central1
            

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: xyz-service
spec:
  template:
    metadata:
      annotations:
        autoscaling.knative.dev/maxScale: '1' 
    spec:
      containers:
      - image: gcr.io/x/y:z
      - env:
        - PORT: 443

# .github/workflows/ci.yml

name: Earthly CI with Google Cloud Run deploy

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    env:
      FORCE_COLOR: 1
    steps:
    - uses: actions/checkout@v2
    - name: Put back the git branch into git (Earthly uses it for tagging)
      run: |
        branch=""
        if [ -n "$GITHUB_HEAD_REF" ]; then
          branch="$GITHUB_HEAD_REF"
        else
          branch="${GITHUB_REF##*/}"
        fi
        git checkout -b "$branch" || true
    - name: Login to GAR
      uses: docker/login-action@v1
      with:
        registry: europe-north1-docker.pkg.dev
        username: _json_key
        password: ${{ secrets.GCP_SA_KEY }}
    - name: Download latest earthly
      run: "sudo /bin/sh -c 'wget https://github.com/earthly/earthly/releases/download/v0.4.4/earthly-linux-amd64 -O /usr/local/bin/earthly && chmod +x /usr/local/bin/earthly'"
    - name: Earthly version
      run: earthly --version
    - name: Run build
      run: earthly --push +docker-google
    - uses: google-github-actions/setup-gcloud@master
      with:
        version: '290.0.1'
        service_account_key: ${{ secrets.GCP_SA_KEY }}
        export_default_credentials: true
    - id: Deploy
      uses: google-github-actions/deploy-cloudrun@main
      with:
        image: europe-north1-docker.pkg.dev/b-jmnorlund-net/tide/jmnoz/tide-tera:latest
        service: tide
        region: europe-north1
        credentials: ${{ secrets.GCP_SA_KEY }}

- secrets = LOCAL_ENV_NAME=secret-name:[revision|latest],...

      - name: Deploy to Cloud Run
        uses: google-github-actions/deploy-cloudrun@main
        with:
          service: cathode
          image: gcr.io/nsg-lobby/cathode:${{ steps.get_version.outputs.VERSION }}
          credentials: ${{ secrets.GCP_SA_KEY }}
          region: us-east4

# Paste your complete GitHub Actions YAML here, removing
# any sensitive values.

# Copyright 2020 Google, LLC.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

name: BuildDockerGCPRun

on:
  push:
    branches:
    - main

env:
  PROJECT_ID: ${{ secrets.GCE_PROJECT }}
  DB_CONNECTON_JSON: ${{ secrets.DB_CONNECTION_SECRETS }}
  ACTIONS_RUNNER_DEBUG: true
  ACTIONS_STEP_DEBUG: true

jobs:
  setup-build-publish-deploy:
    name: Setup, Build, Publish, and Deploy
    runs-on: ubuntu-latest

    steps:
    - name: Checkout
      uses: actions/checkout@v2

    # Setup gcloud CLI
    - uses: google-github-actions/setup-gcloud@master
      with:
        service_account_key: ${{ secrets.GCE_SA_KEY }}
        project_id: ${{ secrets.GCE_PROJECT }}
        export_default_credentials: true

    # Configure Docker to use the gcloud command-line tool as a credential
    # helper for authentication
    - run: |-
        gcloud --quiet auth configure-docker
        
    - name: Copy SQL Credentials
      run: |-
        echo $DB_CONNECTON_JSON > ./config/config.json

    # Build the Docker image
    - name: Build
      run: |-
        docker build --tag "gcr.io/<projectID>/<image>:${GITHUB_SHA::8}" .

    # Push the Docker image to Google Container Registry
    - name: Publish
      run: |-
        docker push "gcr.io/<projectID>/<image>:${GITHUB_SHA::8}"

    - name: Deploy to Cloud Run
      uses: google-github-actions/[email protected]
      with:
        image: gcr.io/<projectID>/<image>:${GITHUB_SHA::8}
        service: <image>
        credentials: ${{ secrets.GCE_SA_KEY }}

name: Deploy Backend Cloud Run

on:
  push:
    branches:
      - master

# adapted form https://github.com/google-github-actions/deploy-cloudrun/blob/main/.github/workflows/example-workflow.yaml
env:
  PROJECT_ID: ${{ secrets.GCP_PROJECT }}
  SERVICE: ${{ secrets.GCP_SERVICE }}
  SA_KEY: ${{ secrets.GCP_SA_KEY }}
  REGION: asia-northeast1
  IMAGE: asia.gcr.io/${{ secrets.GCP_PROJECT }}/${{ secrets.GCP_SERVICE }}

jobs:
  deploy-backend:
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: ./backend
    steps:
      - name: Checkout
        uses: actions/checkout@v2

      - name: Setup Cloud SDK
        uses: google-github-actions/[email protected]
        with:
          project_id: ${{ env.PROJECT_ID }}
          service_account_key: ${{ env.SA_KEY }}
          export_default_credentials: true

      - name: Authorize Docker
        run: gcloud auth configure-docker

      - name: Build and Push Container
        run: |
          docker pull ${{ env.IMAGE }}-cache || true
          docker build . -t ${{ env.IMAGE }}:${{  github.sha }} -f Dockerfile.prod --cache-from=${{ env.IMAGE }}-cache
          docker push ${{ env.IMAGE }}:${{  github.sha }} || true
      - name: Deploy to Cloud Run
        id: deploy
        uses: google-github-actions/deploy-cloudrun@main
        with:
          service: ${{ env.SERVICE }}
          image: ${{ env.IMAGE }}:${{ github.sha }}
          region: ${{ env.REGION }}

      - uses: 8398a7/action-slack@v3
        with:
          status: custom
          fields: workflow,job,commit,repo,ref,author,took
          custom_payload: |
            {
              username: 'deploy-backend',
              icon_emoji: ':actix:',
              attachments: [{
                color: '${{ job.status }}' === 'success' ? 'good' : '${{ job.status }}' === 'failure' ? 'danger' : 'warning',
                text: `Deploy backend done in ${process.env.AS_TOOK} :actix:`,
              }]
            }
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

- name: Deploy to Cloud Run
  uses: google-github-actions/deploy-cloudrun@main
  with:
    image: gcr.io/${{ env.PROJECT_ID }}/${{ env.SERVICE }}:${{  github.sha }}
    metadata: ./service.yaml

- name: Set Image Name
  run: sed -i 's!REPLACE_IMAGE_NAME!gcr.io/${{ env.PROJECT_ID }}/${{ env.SERVICE }}:${{  github.sha }}!g' service.yaml

- name: Deploy to Cloud Run
  uses: google-github-actions/deploy-cloudrun@main
  with:
    metadata: ./service.yaml

        - id: deploy
        uses: google-github-actions/deploy-cloudrun@main
        with:
          image: gcr.io/cyril-test-project/cloud-run-demo
          service: cloud-run-demo```

- name: Deploy to Cloud Run
  uses: google-github-actions/deploy-cloudrun@main
  with:
    components: release (default) | beta | alpha

name: Stage application on Google Cloud Run
on:
  push:
    tags:
    - '*.*.*-rc.*'

jobs:
  deploy:
    name: Deploy job
    runs-on: ubuntu-latest
    steps:
    - name: Checkout the repository
      uses: actions/checkout@v1

    - name: Build Docker image
      run: |
        docker build . --tag eu.gcr.io/${{ secrets.GCLOUD_PROJECT }}/${{ secrets.GCLOUD_APP_NAME }}

    - name: Authenticate into Google Cloud Platform
      uses: google-github-actions/setup-gcloud@master
      with:
        service_account_email: ${{ secrets.GCLOUD_EMAIL }}
        service_account_key: ${{ secrets.GCLOUD_AUTH }}

    - name: Configure Docker to use Google Cloud Platform
      run: "gcloud auth configure-docker --quiet"

    - name: Push image to Google Cloud Container Registry
      run: docker push eu.gcr.io/${{ secrets.GCLOUD_PROJECT }}/${{ secrets.GCLOUD_APP_NAME }}

    - id: get_version
      uses: battila7/get-version-action@v2

    - name: Deploy to Cloud Run
      uses: google-github-actions/[email protected]
      with:
        service: ${{ secrets.GCLOUD_APP_NAME }}
        image: gcr.io/${{ secrets.GCLOUD_PROJECT }}/${{ secrets.GCLOUD_APP_NAME }}
        region: ${{ secrets.GCLOUD_REGION }}
        credentials: ${{ secrets.GCLOUD_AUTH }}
        tag: ${{ steps.get_version.outputs.version }}

- name: 🚀 Deploy to Cloud Run
        id: deploy
        uses: google-github-actions/deploy-cloudrun@v0
        with:
          service: api
          image: gcr.io/${{ secrets.PROJECT_ID }}/api
          region: us-central1
          secrets: |
            /secrets/secrets.json=secrets:latest

    - name: deploy
      uses: google-github-actions/deploy-cloudrun@main
      with:
        region: ${{ env.REGION }}
        image: gcr.io/cloudrun/hello
        revision: hello-${{ github.sha }}

      - name: 🚀 Deploy to Cloud Run
        id: deploy
        uses: google-github-actions/deploy-cloudrun@v0
        with:
          service: api
          image: gcr.io/...
          flags: |
            --set-cloudsql-instances=project:region:db
          env_vars: |
            A=B
          secrets: |
            /secrets/thing=thing:latest

      - name: 🚀 Deploy to Cloud Run
        id: deploy
        uses: google-github-actions/deploy-cloudrun@v0
        with:
          service: api
          image: gcr.io/...
          env_vars: |
            A=B
          secrets: |
            /secrets/thing=thing:latest
          cloudsql: |
            project:region:db

name: Deploy Cloud Run

on:
  workflow_call:
    inputs:
      # <---------- SELECT AUTHENTICATION METHOD --------->
      gcp-sa-auth:
        required: false
        type: boolean
        description: "Set to true to enable GCP Service Account Key authentication"
        default: false
      gcp-oidc-auth:
        required: false
        type: boolean
        description: "Set to true to enable GCP OIDC authentication"
        default: false
      # <--------------- CLOUD RUN OPTIONS --------------->
      cr-service-name:
        required: false
        type: string
        description: "The name to give to the cloud run service"
        default: ${{ github.event.repository.name }}
      cr-image:
        required: true
        type: string
        description: "The full registry + container image path to deploy from"
      cr-region:
        required: true
        type: string
        description: "The GCP region in which to deploy the service"
        default: ""
      cr-suffix:
        required: false
        type: string
        description: "Optional suffix to apply to the revision name (GCP generates if not set)"
        default: ""
      cr-flags:
        required: false
        type: string
        description: "Additional cloud run flags to apply during deployment"
        default: "--port 8080 --cpu 1 --memory 1024Mi --timeout 5m --concurrency 80 --min-instances 0 --max-instances 1 --no-allow-unauthenticated"
      # <----------- GITHUB ENVIRONMENT OPTIONS ---------->
      gh-env-name:
        required: false
        type: string
        description: "The name to give to the environment created in Github"
        default: ${{ github.ref_name }}
      gh-env-url:
        required: false
        type: string
        description: "Override the environment URL. If unset sets to the cloud run service's url"
    secrets:
      # <------------------ OIDC AUTH -------------------->
      wip:
        required: false
        description: "The workfload identity provider to use for OIDC auth"
      service-account:
        required: false
        description: "The service account to impersonate when using OIDC auth"
      # <----------------- SA KEY AUTH ------------------->
      service-account-key:
        required: false
        description: "The service account key to use for service account authentication"
      # <------------------ CLOUD RUN -------------------->
      cr-project-id:
        required: true
        description: "The GCP project in which to deploy the Cloud Run service"
      cr-env-vars:
        required: false
        description: "Comma separated list of KEY=value environment variables to be applied to the service"
    outputs:
      url:
        description: "The URL of the deployed Cloud Run service"
        value: ${{ jobs.deploy.outputs.url }}
      ref-slug:
        description: "A URL sanitized version of the github ref"
        value: ${{ jobs.deploy.outputs.ref-slug }}
      short-sha:
        description: "Captures the short SHA for use in this or later workflow jobs"
        value: ${{ jobs.deploy.outputs.short-sha }}

jobs:
  deploy:
    name: Deploy to Cloud Run
    runs-on: ubuntu-latest
    outputs:
      url: ${{ steps.url.outputs.url }}
      short-sha: ${{ env.GITHUB_SHA_SHORT }}
      ref-slug: ${{ env.GITHUB_REF_SLUG_URL }}
    environment:
      name: ${{ inputs.gh-env-name }}
      url: ${{ steps.url.outputs.url }}
    steps:
      - name: Checkout the code
        uses: actions/checkout@v3

      - name: Slugify github variables
        uses: rlespinasse/[email protected]

      - name: Authenticate to GCP (SA Key)
        if: ${{ inputs.gcp-sa-auth }}
        uses: google-github-actions/auth@v0
        with:
          credentials_json: ${{ secrets.service-account-key }}

      - name: Authenticate to GCP (OIDC)
        if: ${{ inputs.gcp-oidc-auth }}
        uses: google-github-actions/auth@v0
        with:
          workload_identity_provider: ${{ secrets.wip }}
          service_account: ${{ secrets.service-account }}

      - name: Cloud Run
        id: deploy
        uses: google-github-actions/deploy-cloudrun@main
        with:
          project_id: ${{ secrets.cr-project-id }}
          service: ${{ inputs.cr-service-name }}
          image: ${{ inputs.cr-image }}
          region: ${{ inputs.cr-region }}
          suffix: ${{ inputs.cr-suffix }}
          env_vars: ${{ secrets.cr-env-vars }}
          flags: ${{ inputs.cr-flags }}

      # Required to handle override of deployment URL
      - name: Set Deployment URL
        id: url
        run: |
          if [ "${{ inputs.gh-env-url }}" == "" ]; then
            echo "Setting url output to ${{ steps.deploy.outputs.url }}"
            echo "::set-output name=url::${{ steps.deploy.outputs.url }}"
          else
            echo "Setting url output to ${{ inputs.gh-env-url }}"
            echo "::set-output name=url::${{ inputs.gh-env-url }}"
          fi

deploy:
    uses: some-org/workflows/.github/workflows/deploy-cloudrun.yml@main
    needs: build
    with:
      gcp-sa-auth: true
      cr-service-name: ${{ github.ref_name }}-${{ github.event.repository.name }}
      cr-image: ${{ needs.build.outputs.image-name }}:${{ needs.build.outputs.image-tag }}
      cr-region: europe-north1
      cr-suffix: ${{ needs.build.outputs.short-sha }}
      cr-flags: '--port 8080 --cpu 1 --memory 2048Mi --timeout 10m --concurrency 80 --min-instances 1 --max-instances 1 --service-account [email protected] --vpc-connector some-vpc-connector --no-cpu-throttling'
    secrets:
      service-account-key: ${{ secrets.SOME_SA_KEY }}
      cr-project-id: some-gcp-project
      cr-env-vars: API_USERNAME=${{ secrets.DEV_API_USERNAME }}, API_PASSWORD=${{ secrets.DEV_API_PASSWORD }}

name: Staging - Publish to Cloud Run

on:
 push:
   tags:
     - 'staging*'
env:
  IMAGE_NAME: ${{ values.container }}
  IAM_ROLES: 'roles/run.invoker'
jobs:       
    build:
      name: Build and Push Container
      runs-on: ubuntu-latest
      permissions:
          id-token: write
          contents: write
      steps:
        - name: Checkout
          uses: actions/checkout@v2
        
        - name: Authenticate to Google Cloud To Publish to Docker
          uses: google-github-actions/[email protected]
          with:
            workload_identity_provider: 'projects/xxx/locations/global/workloadIdentityPools/github-actions-identity-pool/providers/github-provider'
            service_account: '[email protected]'
          
        - name: Configure GCloud Auth provider with Docker
          run: |
                gcloud auth configure-docker australia-southeast1-docker.pkg.dev
        - name: Build Tag & Push Container
          run: | 
                  tagname=${{ github.ref_name }}
                  docker build -t ${{ env.IMAGE_NAME}} --target prod .
                  docker tag ${{ env.IMAGE_NAME}} australia-southeast1-docker.pkg.dev/acme-dev-tooling/acme-docker/${{ env.IMAGE_NAME}}:$tagname
                  docker push australia-southeast1-docker.pkg.dev/acme-dev-tooling/acme-docker/${{ env.IMAGE_NAME}}:$tagname           
    publish:
      needs: build
      runs-on: ubuntu-latest
      permissions:
          id-token: write
          contents: write
      steps: 
        - name: Checkout
          uses: actions/checkout@v2

        - name: Authenticate to Google Cloud To Read Secrets
          uses: google-github-actions/[email protected]
          with:
            workload_identity_provider: 'projects/xxx/locations/global/workloadIdentityPools/github-actions-identity-pool/providers/github-provider'
            service_account: '[email protected]'

        - name: Setup Python
          uses: actions/setup-python@v2
          with:
            python-version: '3.9.0'
        - name: Install Requirements & Create Service Definition
          run: |
              pip install -r requirements.txt 
              python createServiceDefinition.py
          env:        
            TAG: '${{ github.ref_name }}'
            ENVIRONMENT: dev

        - name: Authenticate to Google Cloud To Deploy To Cloud Run
          uses: google-github-actions/[email protected]
          with:
            credentials_json: '${{ secrets.GOOGLE_CLOUD_RUN_DEPLOYER_DEV_KEYFILE_JSON }}'

        # TODO: figure out why using WLIF seems to ignore the project_id here and fails - if you upgrade the version to 0.7.0

        - name: Deploy to Cloud Run
          uses: google-github-actions/[email protected]
          with: 
              region: australia-southeast1
              project_id: acme-development
              metadata: ./service-definition-updated.yaml

        - name: Authenticate to Google Cloud To Create Service Account
          id: 'auth'
          uses: google-github-actions/[email protected]
          with:
            token_format: 'access_token'
            access_token_lifetime: '300s'
            workload_identity_provider: 'projects/xxx/locations/global/workloadIdentityPools/github-actions-identity-pool/providers/github-provider'
            service_account: '[email protected]'

        - name: Create Service Account
          run: |
              python createServiceAccount.py
          env:        
            ENVIRONMENT: dev
            ACCESS_TOKEN: ${{ steps.auth.outputs.access_token }}
        
        - name: Bind IAM roles # using environment variables setup in the last step.
          run: | 
                 gcloud run services add-iam-policy-binding ${{ env.SERVICE_NAME }} --project=acme-development --region=australia-southeast1 --member='serviceAccount:${{ env.SERVICE_EMAIL }}' --role='roles/run.invoker'
              # additional gcloud commands here do not bind. TODO: find workaround.

 - name: Setup Cloud SDK
      uses: google-github-actions/setup-gcloud@master
      with:
        project_id: ${{ secrets.GCP_PROJECT }}
        service_account_key: ${{ secrets.GCP_SA_KEY }}
        export_default_credentials: true

    - name: Deploy to Cloud Run
      id: deploy
      uses: google-github-actions/deploy-cloudrun@main
      with:
        metadata: service.yaml

on:
  push:
    branches:
      - push-deploy

name: Build and Deploy a Container
env:
  PROJECT_ID: ${{ secrets.GCP_PROJECT }}
  SERVICE: my-test-service
  REGION: us-east4

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2

      - name: Setup Cloud SDK
        uses: google-github-actions/[email protected]
        with:
          project_id: ${{ env.PROJECT_ID }}
          service_account_key: ${{ secrets.GCP_SA_KEY }}
          export_default_credentials: true # Set to true to authenticate the Cloud Run action

      - name: Authorize Docker push
        run: gcloud auth configure-docker

      - name: Build and Push Container
        run: |-
          docker build -t gcr.io/${{ env.PROJECT_ID }}/${{ env.SERVICE }}:${{  github.sha }} frontend/ -f frontend/Dockerfile
          docker push gcr.io/${{ env.PROJECT_ID }}/${{ env.SERVICE }}:${{  github.sha }}

      - name: Deploy to Cloud Run
        id: deploy
        uses: google-github-actions/[email protected]
        with:
          service: ${{ env.SERVICE }}
          image: gcr.io/${{ env.PROJECT_ID }}/${{ env.SERVICE }}:${{  github.sha }}
          region: ${{ env.REGION }}

      - name: Show Output
        run: echo ${{ steps.deploy.outputs.url }}

- name: Authenticate to Google Cloud To Deploy To Cloud Run
            uses: google-github-actions/[email protected]
            with:
              workload_identity_provider: 'projects/xxx/locations/global/workloadIdentityPools/github-actions-identity-pool/providers/github-provider'
              service_account: 'svc-cloud-run-deployer-dev@xxx-dev-tooling.iam.gserviceaccount.com'

          - name: Deploy to Cloud Run
            uses: google-github-actions/[email protected]
            with: 
                region: australia-southeast1
                project_id: xxx-development
                metadata: ./service-definition-updated.yaml

deploy:
    name: Deploy to GCP Cloud Run
    needs: build_n_push
    runs-on: ubuntu-latest

    # permission for gcp
    permissions:
      contents: 'read'
      id-token: 'write'

    steps:
      - name: Checkout # gcp auth needs this step
        uses: actions/checkout@v2

      - name: Get GCP Token
        id: auth
        uses: google-github-actions/auth@v0
        with:
          token_format: access_token
          workload_identity_provider: our/identity/provider
          service_account: our/service/account
          access_token_lifetime: 300s

      - name: Set Docker Metadata
        id: meta
        uses: docker/metadata-action@v3
        with:
          images: our/docker-image
          tags: |
            type=raw,value=latest
      
      - name: Deploy to Cloud Run
        uses: google-github-actions/deploy-cloudrun@v0
        with:
          image: us-central1-docker.pkg.dev/project/repository/${{ steps.meta.outputs.tags }}
          service: servicename
          region: us-central1
          env_vars: |
            RELEASEMODE=development
            NODE_ENV=development
            PORT=4000
            DB_DATABASE=database_name
          secrets: |
            DB_SERVER=db_server:latest
            DB_USERNAME=db_username:latest
            DB_PASSWORD=db_password:latest