actions gh pages
v4.0.0
Note
Voir également l'action officielle de GitHub GitHub Pages en premier.
Il s'agit d'une action GitHub pour déployer vos fichiers statiques sur les pages GitHub . Cette action de déploiement peut être combinée simplement et librement avec des générateurs de sites statiques. (Hugo, Mkdocs, Gatsby, Mdbook, Next, Nuxt, etc.)
L'étape d'exemple suivant déploiera le répertoire ./public vers la branche gh-pages distante.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public Pour les nouvelles actions GitHub: notez que le GITHUB_TOKEN n'est pas un jeton d'accès personnel. Un coureur GitHub Actions crée automatiquement un secret GITHUB_TOKEN pour s'authentifier dans votre flux de travail. Ainsi, vous pouvez commencer à se déployer immédiatement sans aucune configuration.
Trois jetons sont pris en charge.
| Jeton | Repo privé | Repo public | Protocole | Installation |
|---|---|---|---|---|
github_token | ✅️ | ✅️ | Https | Inutile |
deploy_key | ✅️ | ✅️ | Ssh | Nécessaire |
personal_token | ✅️ | ✅️ | Https | Nécessaire |
Remarques: En fait, le GITHUB_TOKEN fonctionne pour le déploiement dans les pages GitHub, mais il a encore quelques limitations. Pour le premier déploiement, nous devons sélectionner la branche gh-pages ou une autre branche dans l'onglet Paramètres du référentiel. Voir premier déploiement avec GITHUB_TOKEN
Toutes les coureurs d'actions: Linux (Ubuntu), macOS et Windows sont prises en charge.
| se mettre en marche | github_token | deploy_key | personal_token |
|---|---|---|---|
| Ubuntu-22.04 | ✅️ | ✅️ | ✅️ |
| Ubuntu-20.04 | ✅️ | ✅️ | ✅️ |
| ubuntu-latest | ✅️ | ✅️ | ✅️ |
| macOS-latest | ✅️ | ✅️ | ✅️ |
| windows-latest | ✅️ | (2) | ✅️ |
✅️ GitHub Enterprise Server est pris en charge au-dessus de 2.22.6 .
Notez que le GITHUB_TOKEN créé par le coureur pourrait ne pas avoir intrinsèquement les privilèges de poussée / publication sur les GHE. Vous devrez peut-être créer / demander un utilisateur technique avec des autorisations d'écriture à votre référentiel cible.
github_tokendeploy_keypersonal_tokenpublish_branchpublish_dirdestination_direxclude_assetscname cnameenable_jekyllallow_empty_commitkeep_filesexternal_repositoryforce_orphanGITHUB_TOKEN Ajoutez votre fichier de workflow .github/workflows/gh-pages.yml et poussez-le vers votre branche par défaut distante.
Voici un exemple de workflow pour Hugo.
name : GitHub Pages
on :
push :
branches :
- main # Set a branch name to trigger deployment
pull_request :
jobs :
deploy :
runs-on : ubuntu-22.04
permissions :
contents : write
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
steps :
- uses : actions/checkout@v3
with :
submodules : true # Fetch Hugo themes (true OR recursive)
fetch-depth : 0 # Fetch all history for .GitInfo and .Lastmod
- name : Setup Hugo
uses : peaceiris/actions-hugo@v2
with :
hugo-version : ' 0.110.0 '
- name : Build
run : hugo --minify
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
# If you're changing the branch from main,
# also change the `main` in `refs/heads/main`
# below accordingly.
if : github.ref == 'refs/heads/main'
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public| Présentation du journal des actions | Journal de pages github |
|---|---|
 |  |
github_token Cette option est pour GITHUB_TOKEN , pas un jeton d'accès personnel.
Un coureur GitHub Actions crée automatiquement un secret GITHUB_TOKEN à utiliser dans votre flux de travail. Vous pouvez utiliser le GITHUB_TOKEN pour vous authentifier dans une exécution de workflow.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public Pour plus de détails sur GITHUB_TOKEN : Authentification automatique des jetons - Docs GitHub
deploy_key Lire Créer la touche SSH Deploy, créez votre touche SSH Deploy et définissez l'option deploy_key comme ce qui suit.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
deploy_key : ${{ secrets.ACTIONS_DEPLOY_KEY }}
publish_dir : ./publicpersonal_token Générez un jeton d'accès personnel ( repo ) et ajoutez-le aux secrets en tant que PERSONAL_TOKEN , il fonctionne ainsi que ACTIONS_DEPLOY_KEY .
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
personal_token : ${{ secrets.PERSONAL_TOKEN }}
publish_dir : ./publicpublish_branch Définissez un nom de branche pour utiliser la branche des pages GitHub. La valeur par défaut est gh-pages .
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_branch : your-branch # default: gh-pagespublish_dir Un répertoire source à déployer sur les pages GitHub. La valeur par défaut est public . Seuls le contenu de ce Dir est poussé à la branche des pages GitHub, gh-pages par défaut.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./out # default: publicdestination_dirCette fonctionnalité est sur bêta. Tous les commentaires sont les bienvenus au numéro 324
Un sous-répertoire de destination sur une branche d'édition. La valeur par défaut est vide.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
destination_dir : subdirexclude_assetsCette fonctionnalité est sur bêta. Tous les commentaires sont les bienvenus au numéro 163
Définissez des fichiers ou des répertoires pour exclure de la publication des actifs. La valeur par défaut est .github . Les valeurs doivent être divisées avec une virgule.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
exclude_assets : ' .github,exclude-file1,exclude-file2 ' Définissez exclude_assets à vider pour inclure le répertoire .github sur les actifs de déploiement.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
deploy_key : ${{ secrets.ACTIONS_DEPLOY_KEY }} # Recommended for this usage
# personal_token: ${{ secrets.PERSONAL_TOKEN }} # An alternative
# github_token: ${{ secrets.GITHUB_TOKEN }} # This does not work for this usage
exclude_assets : ' ' L'option exclude_assets prend en charge les modèles GLOB.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
exclude_assets : ' .github,exclude-file.txt,exclude-dir/**.txt 'cname cname Pour ajouter le fichier CNAME , nous pouvons définir l'option cname . Alternativement, placez votre fichier CNAME dans votre publish_dir . (par exemple public/CNAME )
Pour plus de détails sur le fichier CNAME , lisez la documentation officielle: gérer un domaine personnalisé pour votre site GitHub Pages - GitHub Docs
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
cname : github.comenable_jekyll Si vous souhaitez que les pages GitHub traitent votre site avec le générateur de sites statique Jekyll, définissez enable_jekyll sur true.
Par défaut, cette action signale les pages GitHub que le site ne doit pas être traitée avec Jekyll. Cela se fait en ajoutant un fichier .nojekyll vide sur votre branche de publication. Lorsque ce fichier existe déjà, cette action ne fait rien.
Le contournement de Jekyll rend le déploiement plus rapidement et est nécessaire si vous déploiez des fichiers ou des répertoires qui commencent par des soulignements, car Jekyll considère qu'il s'agit de ressources spéciales et ne les copie pas sur le site final. Il vous suffit de définir enable_jekyll sur TRUE lorsque vous souhaitez déployer un site Web alimenté par Jekyll et laisser les pages GitHub effectuer le traitement Jekyll.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
enable_jekyll : true Pour plus de détails sur .nojekyll : contourner Jekyll sur les pages GitHub - le blog GitHub
allow_empty_commit Par défaut, un engagement ne sera pas généré lorsqu'aucun fichier ne modifie. Si vous souhaitez autoriser un engagement vide, définissez le paramètre facultatif allow_empty_commit sur true .
Par exemple:
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
allow_empty_commit : truekeep_files Par défaut, les fichiers existants dans la branche de publication (ou uniquement dans destination_dir s'ils sont donnés) seront supprimés. Si vous souhaitez que l'action ajoute de nouveaux fichiers mais laissez ceux existants intacts, définissez le paramètre facultatif keep_files sur true .
Notez que les utilisateurs qui utilisent un générateur de site statique n'ont pas besoin de cette option dans la plupart des cas. Veuillez reconsidérer la structure de votre projet et construire des scripts, ou utiliser une fonction intégrée d'un générateur de sites statique avant d'activer ce drapeau.
Par exemple:
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
keep_files : trueAvec le V3, cette option ne prend pas en charge le travail avec l'option Force_orphan. La prochaine version majeure (version 4) le soutiendra. Voir le problème # 455
external_repository Par défaut, vos fichiers sont publiés dans le référentiel qui exécute cette action. Si vous souhaitez publier dans un autre référentiel sur GitHub, définissez la variable d'environnement external_repository sur <username>/<external-repository> .
Par exemple:
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
deploy_key : ${{ secrets.ACTIONS_DEPLOY_KEY }}
external_repository : username/external-repository
publish_branch : your-branch # default: gh-pages
publish_dir : ./public Vous pouvez utiliser deploy_key ou personal_token . Lorsque vous utilisez deploy_key , définissez votre clé privée sur le référentiel qui comprend cette action et définissez votre clé publique sur votre référentiel externe.
Notez que GITHUB_TOKEN n'a aucune autorisation d'accéder à des référentiels externes. Veuillez créer un jeton d'accès personnel et le définir sur personal_token comme personal_token: ${{ secrets.PERSONAL_TOKEN }} .
Cas d'utilisation:
Un compte de plan gratuit GitHub ne peut pas utiliser les pages GitHub dans un référentiel privé. Pour rendre votre contenu source privé et le déployer avec les pages GitHub, vous pouvez déployer votre site d'un référentiel privé à un référentiel public en utilisant cette option.
peaceiris/homepage : Un référentiel privé exécutant cette action avec external_repository: peaceiris/peaceiris.github.iopeaceiris/peaceiris.github.io : un référentiel public utilisant des pages GitHubforce_orphan Nous pouvons définir l'option force_orphan: true . Cela vous permet de faire votre succursale de publication avec seulement le dernier engagement.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
force_orphan : true Définir git config user.name et git config user.email . Un commit est toujours créé avec le même utilisateur.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
user_name : ' github-actions[bot] '
user_email : ' github-actions[bot]@users.noreply.github.com ' 
Définissez un message de validation personnalisé. Lorsque nous créons un engagement avec un message docs: Update some post , un commit de déploiement sera généré avec un message docs: Update some post ${GITHUB_SHA} .
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
commit_message : ${{ github.event.head_commit.message }} 
Pour définir un message de validation personnalisé complet sans hachage de validation déclenchée, utilisez l'option full_commit_message au lieu de l'option commit_message .
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
full_commit_message : ${{ github.event.head_commit.message }}Voici un exemple de workflow.
name : GitHub Pages
on :
push :
branches :
- main
tags :
- ' v*.*.* '
jobs :
deploy :
runs-on : ubuntu-22.04
permissions :
contents : write
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
steps :
- uses : actions/checkout@v3
- name : Some build
- name : Prepare tag
id : prepare_tag
if : startsWith(github.ref, 'refs/tags/')
run : |
echo "DEPLOY_TAG_NAME=deploy-${TAG_NAME}" >> "${GITHUB_OUTPUT}"
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
tag_name : ${{ steps.prepare_tag.outputs.DEPLOY_TAG_NAME }}
tag_message : ' Deployment ${{ github.ref_name }} 'Commandes sur une machine locale.
$ # On a main branch
$ git tag -a " v1.2.3 " -m " Release v1.2.3 "
$ git push origin " v1.2.3 "
$ # After deployment
$ git fetch origin
$ git tag
deploy-v1.2.3 # Tag on the gh-pages branch
v1.2.3 # Tag on the main branchGénérez votre clé de déploiement avec la commande suivante.
ssh-keygen -t rsa -b 4096 -C " $( git config user.email ) " -f gh-pages -N " "Vous obtiendrez 2 fichiers:
gh-pages.pub est une clé publiquegh-pages est une clé privéeEnsuite, accédez aux paramètres du référentiel
ACTIONS_DEPLOY_KEY| Ajoutez votre clé publique | Succès |
|---|---|
 |  |
| Ajoutez votre clé privée | Succès |
|---|---|
 |  |
GITHUB_TOKEN Le GITHUB_TOKEN a des limites pour le premier déploiement, nous devons donc sélectionner la branche des pages GitHub sur l'onglet Paramètres du référentiel. Après cela, faites le deuxième déploiement comme les images suivantes.
| Le premier déploiement a échoué | Accédez à l'onglet Paramètres |
|---|---|
 |  |
| Sélectionner la branche | Déploier à nouveau et réussir |
|---|---|
 | |
Si l'action ne parvient pas à pousser le commit ou la balise avec l'erreur suivante:
/usr/bin/git push origin gh-pages
remote: Write access to repository not granted.
fatal: unable to access 'https://github.com/username/repository.git/': The requested URL returned error: 403
Error: Action failed with "The process '/usr/bin/git' failed with exit code 128" Veuillez ajouter l'autorisation d'écriture aux permissions.contents dans un workflow / travail.
permissions :
contents : write Alternativement, vous pouvez configurer les autorisations GITHUB_TOKEN par défaut en sélectionnant les autorisations de lecture et d'écriture.
Nous vous recommandons d'utiliser la version la dernière et spécifique de cette action pour un CI / CD stable. Il est utile de regarder ce référentiel (version uniquement) pour vérifier la dernière version de cette action.
Pour une mise à jour continue, nous pouvons utiliser le github native Depenabot. Voici un exemple de configuration du bot. Le fichier de configuration est situé dans .github/dependabot.yml .
version : 2
updates :
- package-ecosystem : " github-actions "
directory : " / "
schedule :
interval : " daily "
labels :
- " CI/CD "
commit-message :
prefix : ciVoir la documentation officielle pour plus de détails sur la dépendance: garder vos dépendances à jour automatiquement - GitHub Docs
Pour le déploiement régulier, nous pouvons définir le déclencheur de flux de travail on.schedule . Voir les événements programmés | Événements qui déclenchent des flux de travail - GitHub Docs
Pour le déploiement manuellement, nous pouvons définir le déclencheur de flux de travail on.workflow_dispatch . Voir les événements manuels workflow_dispatch | Événements qui déclenchent des flux de travail - GitHub Docs
name : GitHub Pages
on :
push :
branches :
- main
schedule :
- cron : " 22 22 * * * "
workflow_dispatch :
jobs :
deploy :
runs-on : ubuntu-22.04
permissions :
contents : write
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
steps :
...cf. Support: exécution de Hashref Disabled / Broken vs GitHub Actions Security Best Practice? · Numéro # 712 · PeaceIris / Actions-GH-Pages
Notre projet construit et fournit des actifs de construction uniquement lors de la création d'une version. Il s'agit d'empêcher l'utilisateur d'exécuter cette action avec une branche spécifique (comme Main). Par exemple, si nous maintenons des actifs de construction dans la branche principale et que les utilisateurs utilisent cette action comme suit, une version majeure comprenant des modifications de rupture brisera silencieusement le flux de travail CI des utilisateurs.
- uses : peaceiris/actions-gh-pages@main # Bad example!
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./publicDans ce projet, une étiquette majeure (par exemple V3) est garantie sans aucun changement de rupture. Mais, nous vous recommandons d'utiliser une balise ou un hachage de validation pour la stabilité de vos workflows.
- uses : peaceiris/[email protected] # tag: Better
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public - uses : peaceiris/actions-gh-pages@373f7f263a76c20808c831209c920827a82a2847 # commit hash of v3.9.3: Best!
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./publicPour vérifier l'actif de libération, nous pouvons utiliser les commandes suivantes.
git clone https://github.com/peaceiris/actions-gh-pages.git
cd ./actions-gh-pages
git checkout v3.9.3
nvm install
nvm use
npm i -g npm
npm ci
npm run build
git diff ./lib/index.js # We will get zero exit code Hexo, Vuepress, React-static, gridome, création-réaction-app et ainsi de suite. Veuillez vérifier où est votre répertoire de sortie avant de pousser votre flux de travail. Par exemple, create-react-app nécessite que publish_dir soit défini sur ./build
Prémisse: les dépendances sont gérées par package.json et package-lock.json
name : GitHub Pages
on :
push :
branches :
- main
pull_request :
jobs :
deploy :
runs-on : ubuntu-22.04
permissions :
contents : write
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
steps :
- uses : actions/checkout@v3
- name : Setup Node
uses : actions/setup-node@v3
with :
node-version : ' 14 '
- name : Cache dependencies
uses : actions/cache@v3
with :
path : ~/.npm
key : ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
restore-keys : |
${{ runner.os }}-node-
- run : npm ci
- run : npm run build
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
if : github.ref == 'refs/heads/main'
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./publicUn exemple pour le projet Gatsby (Gatsby.js) avec Gatsby-Starter-blog
name : GitHub Pages
on :
push :
branches :
- main
pull_request :
jobs :
deploy :
runs-on : ubuntu-22.04
permissions :
contents : write
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
steps :
- uses : actions/checkout@v3
- name : Setup Node
uses : actions/setup-node@v3
with :
node-version : ' 14 '
- name : Cache dependencies
uses : actions/cache@v3
with :
path : ~/.npm
key : ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
restore-keys : |
${{ runner.os }}-node-
- run : npm ci
- run : npm run format
- run : npm run test
- run : npm run build
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
if : github.ref == 'refs/heads/main'
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./publicUn exemple pour le projet Next.js (react.js) avec Create-next-App
name : GitHub Pages
on :
push :
branches :
- main
pull_request :
jobs :
deploy :
runs-on : ubuntu-22.04
permissions :
contents : write
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
steps :
- uses : actions/checkout@v3
- name : Setup Node
uses : actions/setup-node@v3
with :
node-version : ' 14 '
- name : Get yarn cache
id : yarn-cache
run : echo "YARN_CACHE_DIR=$(yarn cache dir)" >> "${GITHUB_OUTPUT}"
- name : Cache dependencies
uses : actions/cache@v3
with :
path : ${{ steps.yarn-cache.outputs.YARN_CACHE_DIR }}
key : ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
restore-keys : |
${{ runner.os }}-yarn-
- run : yarn install --frozen-lockfile
- run : yarn build
- run : yarn export
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
if : github.ref == 'refs/heads/main'
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./outUn exemple pour Nuxt.js (Vue.js) Projet avec Create-Nuxt-App
name : GitHub Pages
on :
push :
branches :
- main
pull_request :
jobs :
deploy :
runs-on : ubuntu-22.04
permissions :
contents : write
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
steps :
- uses : actions/checkout@v3
- name : Setup Node
uses : actions/setup-node@v3
with :
node-version : ' 14 '
- name : Cache dependencies
uses : actions/cache@v3
with :
path : ~/.npm
key : ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
restore-keys : |
${{ runner.os }}-node-
- run : npm ci
- run : npm test
- run : npm run generate
- name : deploy
uses : peaceiris/actions-gh-pages@v4
if : github.ref == 'refs/heads/main'
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./distUn exemple de workflow pour Docusaurus.
npx @docusaurus/init@next init website classic est utile pour créer un nouveau projet Docusaurus.
# .github/workflows/deploy.yml
name : GitHub Pages
on :
push :
branches :
- main
paths :
- ' .github/workflows/deploy.yml '
- ' website/** '
pull_request :
jobs :
deploy :
runs-on : ubuntu-22.04
permissions :
contents : write
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
defaults :
run :
working-directory : website
steps :
- uses : actions/checkout@v3
- name : Setup Node
uses : actions/setup-node@v3
with :
node-version : ' 14 '
- name : Get yarn cache
id : yarn-cache
run : echo "YARN_CACHE_DIR=$(yarn cache dir)" >> "${GITHUB_OUTPUT}"
- name : Cache dependencies
uses : actions/cache@v3
with :
path : ${{ steps.yarn-cache.outputs.YARN_CACHE_DIR }}
key : ${{ runner.os }}-website-${{ hashFiles('**/yarn.lock') }}
restore-keys : |
${{ runner.os }}-website-
- run : yarn install --frozen-lockfile
- run : yarn build
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
if : github.ref == 'refs/heads/main'
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./website/buildPelican, Mkdocs, Sphinx, etc.
Prémisse: les dépendances sont gérées par requirements.txt
name : GitHub Pages
on :
push :
branches :
- main
pull_request :
jobs :
deploy :
runs-on : ubuntu-22.04
permissions :
contents : write
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
steps :
- uses : actions/checkout@v3
- name : Setup Python
uses : actions/setup-python@v3
with :
python-version : ' 3.8 '
- name : Upgrade pip
run : |
# install pip=>20.1 to use "pip cache dir"
python3 -m pip install --upgrade pip
- name : Get pip cache dir
id : pip-cache
run : echo "dir=$(pip cache dir)" >> $GITHUB_OUTPUT
- name : Cache dependencies
uses : actions/cache@v3
with :
path : ${{ steps.pip-cache.outputs.dir }}
key : ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
restore-keys : |
${{ runner.os }}-pip-
- name : Install dependencies
run : python3 -m pip install -r ./requirements.txt
- run : mkdocs build
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
if : github.ref == 'refs/heads/main'
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./siteUn exemple de workflow GitHub Actions pour déployer le site Rust-Lang / MDBook aux pages GitHub.
name : GitHub Pages
on :
push :
branches :
- main
pull_request :
jobs :
deploy :
runs-on : ubuntu-22.04
permissions :
contents : write
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
steps :
- uses : actions/checkout@v3
- name : Setup mdBook
uses : peaceiris/actions-mdbook@v1
with :
mdbook-version : ' 0.4.8 '
# mdbook-version: 'latest'
- run : mdbook build
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
if : github.ref == 'refs/heads/main'
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./book Astuce: vous voudrez peut-être publier vos RustDocs. Et utilisez des liens relatifs à celui-ci à partir des documents MD, et faites-les vérifier par mdbook . Ensuite, selon le DOC, vous pouvez mettre ./target/doc/ à votre ./book/src dir avant mdbook build , puis il finira ./book/html/ et dans vos pages github.
Un exemple de workflow for Flutter Web Project.
name : GitHub Pages
on :
push :
branches :
- main
pull_request :
jobs :
deploy :
runs-on : ubuntu-22.04
permissions :
contents : write
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
steps :
- uses : actions/checkout@v3
- name : Setup Flutter
run : |
git clone https://github.com/flutter/flutter.git --depth 1 -b beta _flutter
echo "${GITHUB_WORKSPACE}/_flutter/bin" >> ${GITHUB_PATH}
- name : Install
run : |
flutter config --enable-web
flutter pub get
- name : Build
run : flutter build web
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
if : github.ref == 'refs/heads/main'
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./build/webUn exemple de workflow pour l'ELM.
name : GitHub Pages
on :
push :
branches :
- main
pull_request :
jobs :
deploy :
runs-on : ubuntu-22.04
permissions :
contents : write
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
steps :
- uses : actions/checkout@v3
- name : Setup Node
uses : actions/setup-node@v3
with :
node-version : ' 14 '
- name : Setup Elm
run : npm install elm --global
- name : Make
run : elm make --optimize src/Main.elm
- name : Move files
run : |
mkdir ./public
mv ./index.html ./public/
# If you have non-minimal setup with some assets and separate html/js files,
# provide --output=<output-file> option for `elm make` and remove this step
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
if : github.ref == 'refs/heads/main'
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./publicUn exemple de workflow pour Johnsundell / Publish.
name : GitHub Pages
on :
push :
branches :
- main
pull_request :
jobs :
deploy :
runs-on : macos-latest
concurrency :
group : ${{ github.workflow }}-${{ github.ref }}
steps :
- uses : actions/checkout@v3
- uses : actions/cache@v3
with :
path : |
~/Publish_build
.build
key : ${{ runner.os }}-spm-${{ hashFiles('**/Package.resolved') }}
restore-keys : |
${{ runner.os }}-spm-
- name : Setup JohnSundell/Publish
run : |
cd ${HOME}
export PUBLISH_VERSION="0.7.0"
git clone https://github.com/JohnSundell/Publish.git
cd ./Publish && git checkout ${PUBLISH_VERSION}
mv ~/Publish_build .build || true
swift build -c release
cp -r .build ~/Publish_build || true
echo "${HOME}/Publish/.build/release" >> ${GITHUB_PATH}
- run : publish-cli generate
- name : Deploy to GitHub Pages
uses : peaceiris/actions-gh-pages@v4
if : github.ref == 'refs/heads/main'
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./Output
