cupcakearmy/memoir
1
0
Fork 0
mirror of https://github.com/cupcakearmy/memoir.git synced 2025-09-05 23:40:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

docker images

Browse Source
This commit is contained in:
cupcakearmy
2023-03-07 21:41:23 +01:00
parent 5a4ddbbe06
commit d8d96e7323
10 changed files with 72 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
pages/dev_ops/github-actions/composite-actions.md Executable file
View File

@@ -0,0 +1,116 @@
---
tags:
- Github Actions
- DRY
---
# Composite Actions
Often we reuse `steps` inside our different github actions. As we generally want to follow [DRY](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself) principles (and are lazy), which means every duplicated step has potential for improvement.
> There is also a [good guide/tutorial by James Wallis](https://wallis.dev/blog/composite-github-actions), which this is mainly inspired by.
## Composite Actions vs Reusable Workflows
Within Github actions there are two ways to achieve that: **Composite Actions** and **Reusable Workflows**. Here is a [good comparison by cardinalby](https://cardinalby.github.io/blog/post/github-actions/dry-reusing-code-in-github-actions/).
## Key Points of Composite Actions
- Can live in the same repository, but can also be outsourced into it's own.
- Share the same filesystem -> no build artifacts need to be passed around.
- Secrets cannot be accessed directly, need to be passed.
- Each action has to have it's own directory with an `action.yaml` file inside it.
- When executing raw commands we need to specify the `shell` we are running in.
## Example
The example will show how to extract a part of a github action to a composite action. In this case: building some LaTeX files.
```
.github/
├── actions
│ └── build
│ └── action.yaml
└── workflows
├── preview.yml
└── release.yml
```
```yaml
name: 'Latex Builder'
description: 'Checkout and build LaTeX files.'
inputs:
# As we cannot access secrets directly, they must be passed
github-token:
description: 'GitHub token for authentication.'
required: true
runs:
using: 'composite' # This is the magic
steps:
- uses: actions/cache@v3
name: Tectonic Cache
with:
path: ~/.cache/Tectonic
key: ${{ runner.os }}-tectonic-${{ hashFiles('**/*.tex') }}
restore-keys: |
${{ runner.os }}-tectonic-
- uses: wtfjoke/setup-tectonic@v2
with:
github-token: ${{ inputs.github-token }}
- name: Run Tectonic
run: make tectonic
shell: bash # This would not be required in the normal action file
```
```yaml
name: 'Preview'
on:
# ...
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: ./.github/actions/build
with:
github-token: ${{ secrets.GITHUB_TOKEN }}
- name: Upload PDFs
uses: actions/upload-artifact@v2
with:
name: PDFs
path: '*.pdf'
```
```yaml
name: 'Release'
on:
# ...
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: ./.github/actions/build
with:
github-token: ${{ secrets.GITHUB_TOKEN }}
- name: Release
uses: ncipollo/release-action@v1
with:
allowUpdates: true
artifacts: '*.pdf'
token: ${{ secrets.GITHUB_TOKEN }}
```
## Gotchas
- If we use a local composite action, the `actions/checkout@v3` step cannot be inside the composite action, as the step itself is inside the repository, so it does not exist yet in the run.

63
pages/dev_ops/github-actions/github-pages.md Executable file
View File

@@ -0,0 +1,63 @@
---
tags:
- Github Actions
- Pages
- Static Site
---
# Github Pages with Actions
Publish static sites to Github Pages using Actions.
## Example
The example uses `docs` as the built folder containing the static site.
```yaml
name: Docs
on:
push:
branches:
- main
workflow_dispatch:
permissions:
contents: read
pages: write
id-token: write
concurrency:
group: 'pages'
cancel-in-progress: true
jobs:
deploy:
environment:
name: github-pages
url: ${{ steps.deployment.outputs.page_url }}
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
# Build some static assets
- uses: actions/configure-pages@v3
- uses: actions/upload-pages-artifact@v1
with:
path: './docs'
- id: deployment
uses: actions/deploy-pages@v1
```
## Path prefix
Note that we require a path to be set as github pages are published as: `https://<username>.github.io/<repo>/`
### Vite
For vite you can set it with the [base option](https://vitejs.dev/config/shared-options.html#base).
```bash
vite build --emptyOutDir --base=./
```

83
pages/dev_ops/github-actions/latex.md Executable file
View File

@@ -0,0 +1,83 @@
---
tags:
- LaTeX
- Github Actions
- CD
- Pipeline
- Tectonic
---
# Building LaTeX in Github Actions
This pipeline uses [tectonic](https://tectonic-typesetting.github.io) as the build system for LaTeX. Covered here are:
- Custom fonts
- Pipeline
- Upload generated files as artifacts
## Fonts
If we are using custom fonts, we need to make them available first. This means checking them into the repo (or downloading them remotely). In this case I chose storing them as LFS files.
In most Linux systems you can install custom fonts under `~/.fonts`.
```
./fonts/
├── Open_Sans.zip
├── Roboto_Mono.zip
└── install.sh
```
```sh
#!/bin/sh
TARGET=~/.fonts
mkdir -p $TARGET
unzip -o -d "$TARGET/roboto_mono" "./fonts/Roboto_Mono.zip"
unzip -o -d "$TARGET/open_sans" "./fonts/Open_Sans.zip"
```
## Pipeline
```yaml
name: 'Build LaTeX'
on:
pull_request:
push:
branches:
- main
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
# Optional Cache of downloaded Tex packages
- uses: actions/cache@v3
name: Tectonic Cache
with:
path: ~/.cache/Tectonic
key: ${{ runner.os }}-tectonic-${{ hashFiles('**/*.tex') }}
restore-keys: |
${{ runner.os }}-tectonic-
# Install tectonic
- uses: wtfjoke/setup-tectonic@v2
with:
github-token: ${{ secrets.GITHUB_TOKEN }}
- name: Install fonts
run: ./fonts/install.sh
- name: Build
run: tectonic src/main.tex
- name: Upload PDFs
uses: actions/upload-artifact@v2
with:
name: PDFs
path: '*.pdf'
```

63
pages/dev_ops/github-actions/publish-docker-images.md Normal file
View File

@@ -0,0 +1,63 @@
# Publish Docker images
This is how to publish a docker image simultaneously to the official Docker and Github registries.
**Supported features**
- **x86** and **arm** images
- Push to **both** registries.
- Semver tag labeling
We will assume that our image is called `foo/bar`, so our username is `foo` and the actual package is `bar`
```yaml
name: Publish Docker image
on:
release:
types: [published]
jobs:
docker:
runs-on: ubuntu-latest
steps:
- name: Set up QEMU
uses: docker/setup-qemu-action@v2
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v2
with:
install: true
- name: Docker Labels
id: meta
uses: docker/metadata-action@v4
with:
images: |
foo/bar
ghcr.io/${{ github.repository }}
# This assumes your repository is also github.com/foo/bar
# You could also use ghcr.io/foo/some-package as long as you are the user/org "foo"
tags: |
type=semver,pattern={{version}}
type=semver,pattern={{major}}.{{minor}}
type=semver,pattern={{major}}
- name: Log in to Docker Hub
uses: docker/login-action@v2
with:
username: ${{ secrets.DOCKER_USERNAME }}
password: ${{ secrets.DOCKER_TOKEN }}
- name: Log in to the Container registry
uses: docker/login-action@v2
with:
registry: ghcr.io
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: Build and push
uses: docker/build-push-action@v3
with:
platforms: linux/amd64,linux/arm64
push: true
tags: ${{ steps.meta.outputs.tags }}
```