actions gh pages
v4.0.0
Nota
Ver también la acción oficial de Github Pages GitHub primero.
Esta es una acción de GitHub para implementar sus archivos estáticos en las páginas GitHub . Esta acción de implementación se puede combinar de manera simple y libre con generadores de sitios estáticos. (Hugo, Mkdocs, Gatsby, Mdbook, Next, Nuxt, etc.).
El siguiente paso de ejemplo implementará el directorio ./public en la rama remota gh-pages .
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public Para los novatos de las acciones de GitHub: Tenga en cuenta que el GITHUB_TOKEN no es un token de acceso personal. Un corredor de acciones de GitHub crea automáticamente un secreto GITHUB_TOKEN para autenticarse en su flujo de trabajo. Por lo tanto, puede comenzar a implementar inmediatamente sin ninguna configuración.
Se apoyan tres tokens.
| Simbólico | Repositorio privado | Repositorio | Protocolo | Configuración |
|---|---|---|---|---|
github_token | ✅️ | ✅️ | Https | Innecesario |
deploy_key | ✅️ | ✅️ | Ssh | Necesario |
personal_token | ✅️ | ✅️ | Https | Necesario |
Notas: En realidad, el GITHUB_TOKEN funciona para implementar las páginas de GitHub, pero todavía tiene algunas limitaciones. Para la primera implementación, necesitamos seleccionar la rama gh-pages u otra rama en la pestaña Configuración del repositorio. Ver primera implementación con GITHUB_TOKEN
Se admiten todas las acciones de las acciones: Linux (Ubuntu), MacOS y Windows.
| corredizo | github_token | deploy_key | personal_token |
|---|---|---|---|
| Ubuntu-22.04 | ✅️ | ✅️ | ✅️ |
| Ubuntu-20.04 | ✅️ | ✅️ | ✅️ |
| Ubuntu-lateral | ✅️ | ✅️ | ✅️ |
| MacOS-lateral | ✅️ | ✅️ | ✅️ |
| más de Windows | ✅️ | (2) | ✅️ |
✅️ GitHub Enterprise Server es compatible por encima de 2.22.6 .
Tenga en cuenta que el GITHUB_TOKEN creado por el corredor podría no tener inherentemente privilegios de empuje/publicar en GHES. Es posible que deba crear/solicitar a un usuario técnico con permisos de escritura a su repositorio de destino.
github_tokendeploy_keypersonal_tokenpublish_branchpublish_dirdestination_direxclude_assetscname cnameenable_jekyll incorporadoallow_empty_commitkeep_filesexternal_repositoryforce_orphanGITHUB_TOKEN Agregue su archivo de flujo de trabajo .github/workflows/gh-pages.yml y presione a su rama remota predeterminada.
Aquí hay un ejemplo de flujo de trabajo para 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| Acción Descripción general del registro | Log de páginas de Github |
|---|---|
 |  |
github_token Esta opción es para GITHUB_TOKEN , no un token de acceso personal.
Un corredor de acciones de GitHub crea automáticamente un secreto GITHUB_TOKEN para usar en su flujo de trabajo. Puede usar el GITHUB_TOKEN para autenticar en una ejecución de flujo de trabajo.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public Para más detalles sobre GITHUB_TOKEN : autenticación de token automático - Github Docs
deploy_key Lea la tecla Crear implementada SSH, cree su clave de implementación SSH y establezca la opción deploy_key como la siguiente.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
deploy_key : ${{ secrets.ACTIONS_DEPLOY_KEY }}
publish_dir : ./publicpersonal_token Genere un token de acceso personal ( repo ) y agréguelo a los secretos como PERSONAL_TOKEN , funciona tan bien como ACTIONS_DEPLOY_KEY .
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
personal_token : ${{ secrets.PERSONAL_TOKEN }}
publish_dir : ./publicpublish_branch Establezca un nombre de rama para usar como rama de páginas GitHub. El valor predeterminado son 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 directorio de origen para implementar en las páginas de GitHub. El valor predeterminado es public . Solo el contenido de este DIR se empuja a la rama de las páginas GitHub, gh-pages por defecto.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./out # default: publicdestination_dirEsta característica está en beta. Cualquier comentario es bienvenido en el tema #324
Un subdirectorio de destino en una rama de publicación. El valor predeterminado está vacío.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
destination_dir : subdirexclude_assetsEsta característica está en beta. Cualquier comentario es bienvenido en el tema #163
Establezca archivos o directorios para excluir de la publicación de activos. El valor predeterminado es .github . Los valores deben dividirse con una coma.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
exclude_assets : ' .github,exclude-file1,exclude-file2 ' Establezca exclude_assets para vaciar para incluir el directorio .github a los activos de implementación.
- 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 : ' ' La opción exclude_assets admite patrones del globo.
- 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 Para agregar el archivo CNAME , podemos establecer la opción cname . Alternativamente, coloque su archivo CNAME en su publish_dir . (por ejemplo, public/CNAME )
Para obtener más detalles sobre el archivo CNAME , lea la documentación oficial: Administración de un dominio personalizado para su sitio de 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 incorporado Si desea que las páginas GitHub procesen su sitio con el Generador de sitio estático Jekyll, establezca en enable_jekyll en verdadero.
Por defecto, esta acción señala las páginas de GitHub que el Sitio no se procesará con Jekyll. Esto se hace agregando un archivo .nojekyll vacío en su rama de publicación. Cuando ese archivo ya existe, esta acción no hace nada.
Evitar a Jekyll hace que la implementación sea más rápida y es necesaria si está implementando archivos o directorios que comienzan con subrayos, ya que Jekyll considera que estos son recursos especiales y no los copia al sitio final. Solo necesita establecer enable_jekyll en True cuando desee implementar un sitio web a prueba de Jekyll y dejar que las páginas de GitHub realicen el procesamiento de Jekyll.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
enable_jekyll : true Para más detalles sobre .nojekyll : omitiendo Jekyll en las páginas de Github - The Github Blog
allow_empty_commit Por defecto, no se generará una confirmación cuando no cambie el archivo. Si desea permitir una confirmación vacía, establezca el parámetro opcional allow_empty_commit en true .
Por ejemplo:
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
allow_empty_commit : truekeep_files De forma predeterminada, se eliminarán los archivos existentes en la rama Publish (o solo en destination_dir si se dan). Si desea que la acción agregue nuevos archivos pero deje los existentes intactos, configure el parámetro opcional keep_files en true .
Tenga en cuenta que los usuarios que están utilizando un generador de sitio estático no necesitan esta opción en la mayoría de los casos. Reconsidere su estructura de proyecto y creación de scripts, o use una característica incorporada de un generador de sitios estático antes de habilitar este indicador.
Por ejemplo:
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
keep_files : trueCon el V3, esta opción no admite trabajar con la opción Force_ORPhan. El próximo lanzamiento principal (versión 4) lo admitirá. Ver el problema #455
external_repository Por defecto, sus archivos se publican en el repositorio que ejecuta esta acción. Si desea publicar en otro repositorio en GitHub, establezca la variable de entorno external_repository en <username>/<external-repository> .
Por ejemplo:
- 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 Puede usar deploy_key o personal_token . Cuando use deploy_key , establezca su clave privada en el repositorio que incluye esta acción y establezca su clave pública en su repositorio externo.
Tenga en cuenta que GITHUB_TOKEN no tiene permiso para acceder a repositorios externos. Cree un token de acceso personal y configúrelo en personal_token como personal_token: ${{ secrets.PERSONAL_TOKEN }} .
Caso de uso:
Una cuenta de plan gratuito de GitHub no puede usar las páginas GitHub en un repositorio privado. Para hacer que su contenido de origen sea privado e implementarlo con las páginas de GitHub, puede implementar su sitio de un repositorio privado a un repositorio público utilizando esta opción.
peaceiris/homepage : un repositorio privado que ejecuta esta acción con external_repository: peaceiris/peaceiris.github.iopeaceiris/peaceiris.github.io : un repositorio público utilizando páginas Githubforce_orphan Podemos establecer la opción force_orphan: true . Esto le permite hacer su sucursal de publicación con solo la última confirmación.
- name : Deploy
uses : peaceiris/actions-gh-pages@v4
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./public
force_orphan : true Establezca git config user.name personalizado y git config user.email . Siempre se crea un confirmación con el mismo usuario.
- 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 ' 
Establezca un mensaje de confirmación personalizada. Cuando creamos una confirmación con un mensaje docs: Update some post , se generará una confirmación de implementación con un mensaje 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 }} 
Para establecer un mensaje de confirmación personalizado sin un hash de confirmación activado, use la opción full_commit_message en lugar de la opción 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 }}Aquí hay un ejemplo de flujo de trabajo.
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 }} 'Comandos en una máquina local.
$ # 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 branchGenere su clave de implementación con el siguiente comando.
ssh-keygen -t rsa -b 4096 -C " $( git config user.email ) " -f gh-pages -N " "Obtendrá 2 archivos:
gh-pages.pub es una clave públicagh-pages es una clave privadaA continuación, vaya a la configuración del repositorio
ACTIONS_DEPLOY_KEY| Agregue su clave pública | Éxito |
|---|---|
 |  |
| Agregue su llave privada | Éxito |
|---|---|
 |  |
GITHUB_TOKEN El GITHUB_TOKEN tiene limitaciones para la primera implementación, por lo que tenemos que seleccionar la rama de páginas GitHub en la pestaña Configuración del repositorio. Después de eso, realice el segundo despliegue como las siguientes imágenes.
| El primer despliegue falló | Ir a la pestaña Configuración |
|---|---|
 |  |
| Rama seleccionada | Desplegarse de nuevo y tener éxito |
|---|---|
 | |
Si la acción no puede presionar el confirmación o la etiqueta con el siguiente error:
/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" Agregue el permiso de escritura a los permissions.contents en un flujo de trabajo/trabajo.
permissions :
contents : write Alternativamente, puede configurar los permisos predeterminados GITHUB_TOKEN seleccionando permisos de lectura y escritura.
Le recomendamos que use la versión más reciente y específica de esta acción para CI/CD estable. Es útil ver este repositorio (solo lanzamiento) para verificar la última versión de esta acción.
Para la actualización continua, podemos usar el nativo de GitHub dependabot. Aquí hay una configuración de ejemplo del bot. El archivo de configuración se encuentra en .github/dependabot.yml .
version : 2
updates :
- package-ecosystem : " github-actions "
directory : " / "
schedule :
interval : " daily "
labels :
- " CI/CD "
commit-message :
prefix : ciConsulte la documentación oficial para obtener más detalles sobre Dependabot: Mantener sus dependencias actualizadas automáticamente - GitHub Docs
Para implementar regularmente, podemos establecer el disparador de flujo de trabajo on.schedule . Ver eventos programados | Eventos que activan flujos de trabajo - Github Docs
Para la implementación manualmente, podemos establecer el activador de flujo de trabajo on.workflow_dispatch . Ver eventos manuales workflow_dispatch | Eventos que activan flujos de trabajo - 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. Soporte: Ejecución de hashref deshabilitado/roto vs GitHub Acciones Seguridad ¿¡¡¡¡¡¡¡¡¡¡¡PRIBUestas. · Problema #712 · PAUSIRIS/Actions-Gh-Pages
Nuestro proyecto construye y proporciona activos de compilación solo al crear una versión. Esto es para evitar que el usuario ejecute esta acción con una rama específica (como Main). Por ejemplo, si mantenemos activos de compilación en la rama principal y los usuarios usan esta acción de la siguiente manera, una versión importante que incluye cambios de ruptura romperá el flujo de trabajo de CI de los usuarios en silencio.
- uses : peaceiris/actions-gh-pages@main # Bad example!
with :
github_token : ${{ secrets.GITHUB_TOKEN }}
publish_dir : ./publicEn este proyecto, se garantiza que una etiqueta importante (p. Ej. V3) no contenga cambios de ruptura. Pero, recomendamos usar una etiqueta o un hash de confirmación para la estabilidad de sus flujos de trabajo.
- 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 : ./publicPara verificar el activo de lanzamiento, podemos usar los siguientes comandos.
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-estático, ruidsome, crea react-app y así sucesivamente. Verifique dónde está su directorio de salida antes de presionar su flujo de trabajo. por ejemplo, create-react-app requiere publish_dir para establecerse en ./build
Premisa: las dependencias son administradas por package.json y 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 ejemplo para el proyecto Gatsby (Gatsby.JS) con 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 ejemplo para el proyecto Next.js (react.js) con 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 ejemplo para el proyecto nuxt.js (vue.js) con 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 ejemplo de flujo de trabajo para Docusaurus.
npx @docusaurus/init@next init website classic es útil para crear un nuevo proyecto 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, Esfinge, etc.
Premisa: las dependencias se gestionan con 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 ejemplo de flujo de trabajo de GitHub Actions para implementar el sitio Rust-Lang/Mdbook en las páginas 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 Sugerencia: es posible que desee publicar sus Rustdocs. Y use enlaces relativos de los documentos de MD, y haga que mdbook lo revise. Luego, según el documento, puede poner ./target/doc/ a su ./book/src Dir antes de que mdbook build y luego terminará en ./book/html/ y en sus páginas de Github.
Un ejemplo de flujo de trabajo para el proyecto web Flutter.
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 ejemplo de flujo de trabajo para 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 ejemplo de flujo de trabajo para 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
