github-actions.md Raw History Folder

GitHub Actions Deployment

Two approaches for deploying with GitHub Actions: the gordon push CLI (recommended) or a Docker-based workflow using Gordon's official action.

Prerequisites

Gordon server running with registry authentication enabled
Deployment token generated with the required scopes
GitHub repository secrets configured

Recommended: gordon push

Use the gordon push CLI for a lightweight, single-step build and deploy.

1. Generate Token

On your Gordon server:

gordon auth token generate \
  --subject github-actions \
  --scopes "push,pull,admin:routes:read,admin:config:write" \
  --expiry 0

Save the token output.

2. Add GitHub Secrets

In your repository: Settings → Secrets → Actions → New repository secret

Secret	Value
`GORDON_TOKEN`	The generated token
`GORDON_REMOTE`	`https://gordon.example.com`

3. Setup Gordon CLI

Add this step to your workflow to install the Gordon binary:

- name: Setup Gordon
  uses: bnema/gordon/.github/actions/setup-gordon@main
  # with:
  #   version: latest  # default, or pin to e.g. v2.0.0

4. Workflow Examples

Deploy on Tag Push

Gordon auto-detects the version from $GITHUB_REF (e.g., refs/tags/v1.2.0 → v1.2.0).

name: Deploy to Gordon

on:
  push:
    tags: ['v*']

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Gordon
        uses: bnema/gordon/.github/actions/setup-gordon@main

      - name: Build and Deploy
        env:
          GORDON_TOKEN: ${{ secrets.GORDON_TOKEN }}
        run: |
          gordon push --build \
            --remote ${{ secrets.GORDON_REMOTE }} \
            --no-confirm

Continuous Deploy on Main

Deploy on every push to main. The version defaults to latest or the output of git describe.

name: Deploy to Gordon

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Gordon
        uses: bnema/gordon/.github/actions/setup-gordon@main

      - name: Build and Deploy
        env:
          GORDON_TOKEN: ${{ secrets.GORDON_TOKEN }}
        run: |
          gordon push --build \
            --remote ${{ secrets.GORDON_REMOTE }} \
            --tag latest \
            --no-confirm

Manual Dispatch

Allow manual deployments with an optional tag input:

name: Deploy to Gordon

on:
  workflow_dispatch:
    inputs:
      tag:
        description: 'Tag to deploy (leave empty to use git describe)'
        required: false

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.inputs.tag || github.ref }}
          fetch-depth: 0

      - name: Setup Gordon
        uses: bnema/gordon/.github/actions/setup-gordon@main

      - name: Build and Deploy
        env:
          GORDON_TOKEN: ${{ secrets.GORDON_TOKEN }}
        run: |
          gordon push --build \
            --remote ${{ secrets.GORDON_REMOTE }} \
            ${{ github.event.inputs.tag && format('--tag {0}', github.event.inputs.tag) || '' }} \
            --no-confirm

Monorepo

Deploy multiple services with separate gordon push calls:

name: Deploy Services

on:
  push:
    tags: ['v*']

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Gordon
        uses: bnema/gordon/.github/actions/setup-gordon@main

      - name: Deploy API
        env:
          GORDON_TOKEN: ${{ secrets.GORDON_TOKEN }}
        run: |
          gordon push --build \
            --remote ${{ secrets.GORDON_REMOTE }} \
            --file ./services/api/Dockerfile \
            myapp-api \
            --no-confirm

      - name: Deploy Web
        env:
          GORDON_TOKEN: ${{ secrets.GORDON_TOKEN }}
        run: |
          gordon push --build \
            --remote ${{ secrets.GORDON_REMOTE }} \
            --file ./services/web/Dockerfile \
            myapp-web \
            --no-confirm

With Build Args

Pass build arguments to the Docker build:

- name: Build and Deploy
  env:
    GORDON_TOKEN: ${{ secrets.GORDON_TOKEN }}
  run: |
    gordon push --build \
      --remote ${{ secrets.GORDON_REMOTE }} \
      --build-arg NODE_ENV=production \
      --build-arg API_URL=https://api.example.com \
      --build-arg BUILD_DATE=${{ github.event.head_commit.timestamp }} \
      --no-confirm

setup-gordon Action Reference

Input	Required	Default	Description
`version`	No	`latest`	Gordon version to install (`v2.0.0` or `latest`)

Output	Description
`version`	The version actually installed
`path`	Path to the installed binary

Alternative: Docker-based Workflow

For environments where installing the Gordon binary is not desired, use Docker directly to build and push to the Gordon registry. Gordon auto-deploys when it receives the image — no explicit deploy step is needed.

Setup

Add these secrets to your repository:

Secret	Value
`GORDON_REGISTRY`	`registry.gordon.example.com`
`GORDON_USERNAME`	`github-actions`
`GORDON_TOKEN`	The generated token

Workflow

name: Deploy to Gordon

on:
  push:
    tags: ['v*']

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Login to Gordon Registry
        run: echo "${{ secrets.GORDON_TOKEN }}" | docker login ${{ secrets.GORDON_REGISTRY }} -u ${{ secrets.GORDON_USERNAME }} --password-stdin

      - name: Build and Push
        run: |
          docker build -t ${{ secrets.GORDON_REGISTRY }}/myapp:${{ github.ref_name }} .
          docker push ${{ secrets.GORDON_REGISTRY }}/myapp:${{ github.ref_name }}

Alternative: Gordon GitHub Action

Use the official bnema/gordon action for a fully declarative workflow. This action handles login, build, and push in a single step.

Setup

Requires the same 3 secrets as the Docker-based workflow: GORDON_REGISTRY, GORDON_USERNAME, GORDON_TOKEN.

Workflow Examples

Deploy on Tag Push

name: Deploy to Gordon

on:
  push:
    tags:
      - 'v*'

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Deploy to Gordon
        uses: bnema/gordon/.github/actions/deploy@main
        with:
          registry: ${{ secrets.GORDON_REGISTRY }}
          username: ${{ secrets.GORDON_USERNAME }}
          password: ${{ secrets.GORDON_TOKEN }}

Continuous Deployment

Deploy on every push to main:

name: Deploy to Gordon

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Deploy to Gordon
        uses: bnema/gordon/.github/actions/deploy@main
        with:
          registry: ${{ secrets.GORDON_REGISTRY }}
          username: ${{ secrets.GORDON_USERNAME }}
          password: ${{ secrets.GORDON_TOKEN }}
          push-latest: 'true'

Manual Deployment

Allow manual deployments with a custom tag:

name: Deploy to Gordon

on:
  workflow_dispatch:
    inputs:
      tag:
        description: 'Tag to deploy'
        required: false

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.inputs.tag || github.ref }}

      - name: Deploy to Gordon
        uses: bnema/gordon/.github/actions/deploy@main
        with:
          registry: ${{ secrets.GORDON_REGISTRY }}
          username: ${{ secrets.GORDON_USERNAME }}
          password: ${{ secrets.GORDON_TOKEN }}
          tag: ${{ github.event.inputs.tag }}

Monorepo Deployment

Deploy multiple services:

name: Deploy Services

on:
  push:
    tags:
      - 'v*'

jobs:
  deploy-api:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: bnema/gordon/.github/actions/deploy@main
        with:
          registry: ${{ secrets.GORDON_REGISTRY }}
          username: ${{ secrets.GORDON_USERNAME }}
          password: ${{ secrets.GORDON_TOKEN }}
          image: myapp-api
          dockerfile: ./services/api/Dockerfile
          context: ./services/api

  deploy-web:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: bnema/gordon/.github/actions/deploy@main
        with:
          registry: ${{ secrets.GORDON_REGISTRY }}
          username: ${{ secrets.GORDON_USERNAME }}
          password: ${{ secrets.GORDON_TOKEN }}
          image: myapp-web
          dockerfile: ./services/web/Dockerfile
          context: ./services/web

With Build Arguments

- uses: bnema/gordon/.github/actions/deploy@main
  with:
    registry: ${{ secrets.GORDON_REGISTRY }}
    username: ${{ secrets.GORDON_USERNAME }}
    password: ${{ secrets.GORDON_TOKEN }}
    build-args: |
      NODE_ENV=production
      API_URL=https://api.example.com
      BUILD_DATE=${{ github.event.head_commit.timestamp }}

Multi-Platform Build

- uses: bnema/gordon/.github/actions/deploy@main
  with:
    registry: ${{ secrets.GORDON_REGISTRY }}
    username: ${{ secrets.GORDON_USERNAME }}
    password: ${{ secrets.GORDON_TOKEN }}
    platforms: linux/amd64,linux/arm64

Action Reference

Inputs

Input	Required	Default	Description
`registry`	Yes	-	Gordon registry URL
`username`	Yes	-	Registry username
`password`	Yes	-	Registry token
`image`	No	repo name	Image name
`tag`	No	git tag/SHA	Image tag
`dockerfile`	No	`./Dockerfile`	Dockerfile path
`context`	No	`.`	Build context
`push-latest`	No	`false`	Also push :latest tag
`platforms`	No	`linux/amd64`	Target platforms
`build-args`	No	-	Build arguments

Outputs

Output	Description
`image`	Full image name
`tag`	Image tag

Deployment Summary

Add a deployment summary to your workflow:

- name: Deploy to Gordon
  id: deploy
  uses: bnema/gordon/.github/actions/deploy@main
  with:
    registry: ${{ secrets.GORDON_REGISTRY }}
    username: ${{ secrets.GORDON_USERNAME }}
    password: ${{ secrets.GORDON_TOKEN }}

- name: Deployment Summary
  run: |
    echo "## Deployment Complete" >> $GITHUB_STEP_SUMMARY
    echo "" >> $GITHUB_STEP_SUMMARY
    echo "**Image:** \`${{ steps.deploy.outputs.image }}\`" >> $GITHUB_STEP_SUMMARY
    echo "**Tag:** \`${{ steps.deploy.outputs.tag }}\`" >> $GITHUB_STEP_SUMMARY

Troubleshooting

Authentication Failed

Error: unauthorized: authentication required

Solution: Verify secrets are correctly set and token has push scope.

Image Not Found After Push

Solution: Ensure Gordon config has a route for the pushed image.

Build Fails

Solution: Check Dockerfile path and build context settings.

source

1# GitHub Actions Deployment
2
3Two approaches for deploying with GitHub Actions: the `gordon push` CLI (recommended) or a Docker-based workflow using Gordon's official action.
4
5## Prerequisites
6
71. Gordon server running with registry authentication enabled
82. Deployment token generated with the required scopes
93. GitHub repository secrets configured
10
11## Recommended: gordon push
12
13Use the `gordon push` CLI for a lightweight, single-step build and deploy.
14
15### 1. Generate Token
16
17On your Gordon server:
18
19```bash
20gordon auth token generate \
21  --subject github-actions \
22  --scopes "push,pull,admin:routes:read,admin:config:write" \
23  --expiry 0
24```
25
26Save the token output.
27
28### 2. Add GitHub Secrets
29
30In your repository: Settings → Secrets → Actions → New repository secret
31
32| Secret | Value |
33|--------|-------|
34| `GORDON_TOKEN` | The generated token |
35| `GORDON_REMOTE` | `https://gordon.example.com` |
36
37### 3. Setup Gordon CLI
38
39Add this step to your workflow to install the Gordon binary:
40
41```yaml
42- name: Setup Gordon
43  uses: bnema/gordon/.github/actions/setup-gordon@main
44  # with:
45  #   version: latest  # default, or pin to e.g. v2.0.0
46```
47
48### 4. Workflow Examples
49
50#### Deploy on Tag Push
51
52Gordon auto-detects the version from `$GITHUB_REF` (e.g., `refs/tags/v1.2.0` → `v1.2.0`).
53
54```yaml
55name: Deploy to Gordon
56
57on:
58  push:
59    tags: ['v*']
60
61jobs:
62  deploy:
63    runs-on: ubuntu-latest
64    steps:
65      - uses: actions/checkout@v4
66
67      - name: Setup Gordon
68        uses: bnema/gordon/.github/actions/setup-gordon@main
69
70      - name: Build and Deploy
71        env:
72          GORDON_TOKEN: ${{ secrets.GORDON_TOKEN }}
73        run: |
74          gordon push --build \
75            --remote ${{ secrets.GORDON_REMOTE }} \
76            --no-confirm
77```
78
79#### Continuous Deploy on Main
80
81Deploy on every push to main. The version defaults to `latest` or the output of `git describe`.
82
83```yaml
84name: Deploy to Gordon
85
86on:
87  push:
88    branches:
89      - main
90
91jobs:
92  deploy:
93    runs-on: ubuntu-latest
94    steps:
95      - uses: actions/checkout@v4
96        with:
97          fetch-depth: 0
98
99      - name: Setup Gordon
100        uses: bnema/gordon/.github/actions/setup-gordon@main
101
102      - name: Build and Deploy
103        env:
104          GORDON_TOKEN: ${{ secrets.GORDON_TOKEN }}
105        run: |
106          gordon push --build \
107            --remote ${{ secrets.GORDON_REMOTE }} \
108            --tag latest \
109            --no-confirm
110```
111
112#### Manual Dispatch
113
114Allow manual deployments with an optional tag input:
115
116```yaml
117name: Deploy to Gordon
118
119on:
120  workflow_dispatch:
121    inputs:
122      tag:
123        description: 'Tag to deploy (leave empty to use git describe)'
124        required: false
125
126jobs:
127  deploy:
128    runs-on: ubuntu-latest
129    steps:
130      - uses: actions/checkout@v4
131        with:
132          ref: ${{ github.event.inputs.tag || github.ref }}
133          fetch-depth: 0
134
135      - name: Setup Gordon
136        uses: bnema/gordon/.github/actions/setup-gordon@main
137
138      - name: Build and Deploy
139        env:
140          GORDON_TOKEN: ${{ secrets.GORDON_TOKEN }}
141        run: |
142          gordon push --build \
143            --remote ${{ secrets.GORDON_REMOTE }} \
144            ${{ github.event.inputs.tag && format('--tag {0}', github.event.inputs.tag) || '' }} \
145            --no-confirm
146```
147
148#### Monorepo
149
150Deploy multiple services with separate `gordon push` calls:
151
152```yaml
153name: Deploy Services
154
155on:
156  push:
157    tags: ['v*']
158
159jobs:
160  deploy:
161    runs-on: ubuntu-latest
162    steps:
163      - uses: actions/checkout@v4
164
165      - name: Setup Gordon
166        uses: bnema/gordon/.github/actions/setup-gordon@main
167
168      - name: Deploy API
169        env:
170          GORDON_TOKEN: ${{ secrets.GORDON_TOKEN }}
171        run: |
172          gordon push --build \
173            --remote ${{ secrets.GORDON_REMOTE }} \
174            --file ./services/api/Dockerfile \
175            myapp-api \
176            --no-confirm
177
178      - name: Deploy Web
179        env:
180          GORDON_TOKEN: ${{ secrets.GORDON_TOKEN }}
181        run: |
182          gordon push --build \
183            --remote ${{ secrets.GORDON_REMOTE }} \
184            --file ./services/web/Dockerfile \
185            myapp-web \
186            --no-confirm
187```
188
189#### With Build Args
190
191Pass build arguments to the Docker build:
192
193```yaml
194- name: Build and Deploy
195  env:
196    GORDON_TOKEN: ${{ secrets.GORDON_TOKEN }}
197  run: |
198    gordon push --build \
199      --remote ${{ secrets.GORDON_REMOTE }} \
200      --build-arg NODE_ENV=production \
201      --build-arg API_URL=https://api.example.com \
202      --build-arg BUILD_DATE=${{ github.event.head_commit.timestamp }} \
203      --no-confirm
204```
205
206### setup-gordon Action Reference
207
208| Input | Required | Default | Description |
209|-------|----------|---------|-------------|
210| `version` | No | `latest` | Gordon version to install (`v2.0.0` or `latest`) |
211
212| Output | Description |
213|--------|-------------|
214| `version` | The version actually installed |
215| `path` | Path to the installed binary |
216
217## Alternative: Docker-based Workflow
218
219For environments where installing the Gordon binary is not desired, use Docker directly to build and push to the Gordon registry. Gordon auto-deploys when it receives the image — no explicit deploy step is needed.
220
221### Setup
222
223Add these secrets to your repository:
224
225| Secret | Value |
226|--------|-------|
227| `GORDON_REGISTRY` | `registry.gordon.example.com` |
228| `GORDON_USERNAME` | `github-actions` |
229| `GORDON_TOKEN` | The generated token |
230
231### Workflow
232
233```yaml
234name: Deploy to Gordon
235
236on:
237  push:
238    tags: ['v*']
239
240jobs:
241  deploy:
242    runs-on: ubuntu-latest
243    steps:
244      - uses: actions/checkout@v4
245
246      - name: Login to Gordon Registry
247        run: echo "${{ secrets.GORDON_TOKEN }}" | docker login ${{ secrets.GORDON_REGISTRY }} -u ${{ secrets.GORDON_USERNAME }} --password-stdin
248
249      - name: Build and Push
250        run: |
251          docker build -t ${{ secrets.GORDON_REGISTRY }}/myapp:${{ github.ref_name }} .
252          docker push ${{ secrets.GORDON_REGISTRY }}/myapp:${{ github.ref_name }}
253```
254
255## Alternative: Gordon GitHub Action
256
257Use the official `bnema/gordon` action for a fully declarative workflow. This action handles login, build, and push in a single step.
258
259### Setup
260
261Requires the same 3 secrets as the Docker-based workflow: `GORDON_REGISTRY`, `GORDON_USERNAME`, `GORDON_TOKEN`.
262
263### Workflow Examples
264
265#### Deploy on Tag Push
266
267```yaml
268name: Deploy to Gordon
269
270on:
271  push:
272    tags:
273      - 'v*'
274
275jobs:
276  deploy:
277    runs-on: ubuntu-latest
278    steps:
279      - uses: actions/checkout@v4
280
281      - name: Deploy to Gordon
282        uses: bnema/gordon/.github/actions/deploy@main
283        with:
284          registry: ${{ secrets.GORDON_REGISTRY }}
285          username: ${{ secrets.GORDON_USERNAME }}
286          password: ${{ secrets.GORDON_TOKEN }}
287```
288
289#### Continuous Deployment
290
291Deploy on every push to main:
292
293```yaml
294name: Deploy to Gordon
295
296on:
297  push:
298    branches:
299      - main
300
301jobs:
302  deploy:
303    runs-on: ubuntu-latest
304    steps:
305      - uses: actions/checkout@v4
306
307      - name: Deploy to Gordon
308        uses: bnema/gordon/.github/actions/deploy@main
309        with:
310          registry: ${{ secrets.GORDON_REGISTRY }}
311          username: ${{ secrets.GORDON_USERNAME }}
312          password: ${{ secrets.GORDON_TOKEN }}
313          push-latest: 'true'
314```
315
316#### Manual Deployment
317
318Allow manual deployments with a custom tag:
319
320```yaml
321name: Deploy to Gordon
322
323on:
324  workflow_dispatch:
325    inputs:
326      tag:
327        description: 'Tag to deploy'
328        required: false
329
330jobs:
331  deploy:
332    runs-on: ubuntu-latest
333    steps:
334      - uses: actions/checkout@v4
335        with:
336          ref: ${{ github.event.inputs.tag || github.ref }}
337
338      - name: Deploy to Gordon
339        uses: bnema/gordon/.github/actions/deploy@main
340        with:
341          registry: ${{ secrets.GORDON_REGISTRY }}
342          username: ${{ secrets.GORDON_USERNAME }}
343          password: ${{ secrets.GORDON_TOKEN }}
344          tag: ${{ github.event.inputs.tag }}
345```
346
347#### Monorepo Deployment
348
349Deploy multiple services:
350
351```yaml
352name: Deploy Services
353
354on:
355  push:
356    tags:
357      - 'v*'
358
359jobs:
360  deploy-api:
361    runs-on: ubuntu-latest
362    steps:
363      - uses: actions/checkout@v4
364      - uses: bnema/gordon/.github/actions/deploy@main
365        with:
366          registry: ${{ secrets.GORDON_REGISTRY }}
367          username: ${{ secrets.GORDON_USERNAME }}
368          password: ${{ secrets.GORDON_TOKEN }}
369          image: myapp-api
370          dockerfile: ./services/api/Dockerfile
371          context: ./services/api
372
373  deploy-web:
374    runs-on: ubuntu-latest
375    steps:
376      - uses: actions/checkout@v4
377      - uses: bnema/gordon/.github/actions/deploy@main
378        with:
379          registry: ${{ secrets.GORDON_REGISTRY }}
380          username: ${{ secrets.GORDON_USERNAME }}
381          password: ${{ secrets.GORDON_TOKEN }}
382          image: myapp-web
383          dockerfile: ./services/web/Dockerfile
384          context: ./services/web
385```
386
387#### With Build Arguments
388
389```yaml
390- uses: bnema/gordon/.github/actions/deploy@main
391  with:
392    registry: ${{ secrets.GORDON_REGISTRY }}
393    username: ${{ secrets.GORDON_USERNAME }}
394    password: ${{ secrets.GORDON_TOKEN }}
395    build-args: |
396      NODE_ENV=production
397      API_URL=https://api.example.com
398      BUILD_DATE=${{ github.event.head_commit.timestamp }}
399```
400
401#### Multi-Platform Build
402
403```yaml
404- uses: bnema/gordon/.github/actions/deploy@main
405  with:
406    registry: ${{ secrets.GORDON_REGISTRY }}
407    username: ${{ secrets.GORDON_USERNAME }}
408    password: ${{ secrets.GORDON_TOKEN }}
409    platforms: linux/amd64,linux/arm64
410```
411
412### Action Reference
413
414#### Inputs
415
416| Input | Required | Default | Description |
417|-------|----------|---------|-------------|
418| `registry` | Yes | - | Gordon registry URL |
419| `username` | Yes | - | Registry username |
420| `password` | Yes | - | Registry token |
421| `image` | No | repo name | Image name |
422| `tag` | No | git tag/SHA | Image tag |
423| `dockerfile` | No | `./Dockerfile` | Dockerfile path |
424| `context` | No | `.` | Build context |
425| `push-latest` | No | `false` | Also push :latest tag |
426| `platforms` | No | `linux/amd64` | Target platforms |
427| `build-args` | No | - | Build arguments |
428
429#### Outputs
430
431| Output | Description |
432|--------|-------------|
433| `image` | Full image name |
434| `tag` | Image tag |
435
436#### Deployment Summary
437
438Add a deployment summary to your workflow:
439
440```yaml
441- name: Deploy to Gordon
442  id: deploy
443  uses: bnema/gordon/.github/actions/deploy@main
444  with:
445    registry: ${{ secrets.GORDON_REGISTRY }}
446    username: ${{ secrets.GORDON_USERNAME }}
447    password: ${{ secrets.GORDON_TOKEN }}
448
449- name: Deployment Summary
450  run: |
451    echo "## Deployment Complete" >> $GITHUB_STEP_SUMMARY
452    echo "" >> $GITHUB_STEP_SUMMARY
453    echo "**Image:** \`${{ steps.deploy.outputs.image }}\`" >> $GITHUB_STEP_SUMMARY
454    echo "**Tag:** \`${{ steps.deploy.outputs.tag }}\`" >> $GITHUB_STEP_SUMMARY
455```
456
457## Troubleshooting
458
459### Authentication Failed
460
461```
462Error: unauthorized: authentication required
463```
464
465**Solution:** Verify secrets are correctly set and token has `push` scope.
466
467### Image Not Found After Push
468
469**Solution:** Ensure Gordon config has a route for the pushed image.
470
471### Build Fails
472
473**Solution:** Check Dockerfile path and build context settings.
474
475## Related
476
477- [GitLab CI](./gitlab-ci.md)
478- [Generic CI](./generic-ci.md)
479- [Deployment Overview](./index.md)
480- [Authentication](../config/auth.md)
481- [Push Command](../cli/push.md)
482- [Rollback](./rollback.md)

github-actions.md RawHistoryFolder

GitHub Actions Deployment

Prerequisites

Recommended: gordon push

1. Generate Token

2. Add GitHub Secrets

3. Setup Gordon CLI

4. Workflow Examples

Deploy on Tag Push

Continuous Deploy on Main

Manual Dispatch

Monorepo

With Build Args

setup-gordon Action Reference

Alternative: Docker-based Workflow

Setup

Workflow

Alternative: Gordon GitHub Action

Setup

Workflow Examples

Deploy on Tag Push

Continuous Deployment

Manual Deployment

Monorepo Deployment

With Build Arguments

Multi-Platform Build

Action Reference

Inputs

Outputs

Deployment Summary

Troubleshooting

Authentication Failed

Image Not Found After Push

Build Fails

Related

github-actions.md Raw History Folder