Compilaciones de iOS automáticas con acciones de GitHub utilizando Match

Configurando CI/CD para aplicaciones de Capacitor puede ser complejo y tiempo consumidor. Aquí está lo que debes saber:

Recomendado para Nuevas Compilaciones: Utilice la Compilación de Capgo

Ahora recomendamos utilizar Compilación de Capgo con la Capgo CLI para compilaciones nativas de Capacitor. Esta guía de Fastlane Match se mantiene para equipos que mantienen pipelines de acciones de GitHub existentes, pero las nuevas compilaciones de iOS deben utilizar la Capgo CLI para que no tengas que mantener repositorios de Fastlane, Match, ejecutores de Xcode, certificados y scripts de carga.

Compilación de Capgo para CI/CD por Capgo

Saltarse la configuración de Fastlane Match, ejecutor de Xcode, certificado, perfil de provisión y script de carga. Compilación de Capgo realiza compilaciones nativas de iOS firmadas desde tu pipeline de CI/CD existente:

Funciona con tu pipeline: Desencadena la compilación Capgo desde GitHub Actions, GitLab CI, Jenkins o scripts locales después de tu compilación web y npx cap sync.
Desde secretos de CIfirmado
: Mantén las llaves de App Store Connect, certificados, perfiles de provisión, contraseñas y IDs de equipo en tus propios secretos de CI.: Capgo Build provides maintained Apple build environments, so you do not have to manage macOS runners, Xcode images, Fastlane, or Match repositories.
: __CAPGO_KEEP_0__ Build proporciona entornos de compilación Apple mantenidos, por lo que no tienes que gestionar ejecutores de macOS, imágenes de Xcode, Fastlane o repositorios de Match.: Download signed artifacts for QA or submit release builds through the Capgo CLI.

: Descarga artículos firmados para QA o presenta lanzamientos a través del __CAPGO_KEEP_0 CAPGO_KEEP_1__.

Capgo plans start at $12/month
contexto: Etiqueta de navegación para la página de Precio. Página/área: Capgo Builder / producto de compilación nativa en la nube. Papel: subtítulo de sección o encabezado. Visto en: página native-build.astro. Clave de mensaje `native_build_builder_precio_eyebrow` (Precio del constructor de compilación nativa). | Etiqueta de navegación para la página de Precio. Página/área: sitio web de marketing de Capgo. Papel: botón de llamada a la acción o etiqueta de enlace. Visto en: componente BlogMidArticleCta.astro. Clave de mensaje `blog_mid_article_china_cta_precio_button` (Botón de Precio de la sección de artículos de blog). | Etiqueta de navegación para la página de Precio. Página/área: sitio web de marketing de Capgo. Papel: etiqueta de UI corta o elemento de navegación. Visto en: pie de página, encabezado de sitio, página de Precio.astro. Clave de mensaje `precio` (Precio).
Los minutos adicionales de construcción se facturan por minuto mediante créditos

Configura Capgo Build en CI/CD

Guía de configuración manual

Aquí está lo que debes hacer:

Entrega continua para iOS utilizando Fastlane y GitHub Acciones utilizando match

Requisitos previos

Antes de continuar con el tutorial...

Asegúrate de tener instalado Fastlane en tu máquina de desarrollo. miembro del programa de desarrolladores de iOS.
Deseo de leer 😆…
Desire to read 😆…
A un equipo de muchos devs, en su lugar recomendamos utilizar fastlane cert para flujos de trabajo más simples.

Importante sobre el precio

Precio GitHub Action

https://github.com/features/actions

El servicio es ‘gratuito’ hasta la limitación, dependiendo de la máquina elegida.
Vamos a utilizar una máquina macOS puedes ver en la captura de pantalla su precio y límites (precios a la creación de este tutorial, pueden cambiar en el futuro)

🔴 Una vez advertidos de los requisitos y precios, si lo deseas, continuamos…

📣 En el post asumimos que tenemos la aplicación creada en iTunes connect, sí tenemos los certificados del ecosistema Apple, todo se copiará por Fastlane!

¡Vamos a sumergirnos!

Pasos a seguir en el post

Usando App Store Connect API con Fastlane Match
Requisitos
Crear una clave de App Store Connect API
Usar una clave de App Store Connect API
Copiar archivos de Fastlane
Configurar Fastlane match

1. Usando App Store Connect API con Fastlane Match

Desde febrero de 2021, se requiere autenticación en dos factores o verificación en dos pasos para todos los usuarios para iniciar sesión en App Store Connect. Esta capa adicional de seguridad para su ID de Apple ayuda a asegurarse de que solo usted puede acceder a su cuenta.
Desde Soporte de Apple

Empezar con match requiere que revoces tus certificados existentes. Pero no te preocupes, tendrás el nuevo directamente.

Requisitos

Para poder utilizar App Store Connect API, Fastlane necesita tres cosas.

ID del emisor.
ID de clave.
Archivo de clave o contenido de clave.

Crear una clave de App Store Connect API

Para generar claves, debes tener permiso de administrador en App Store Connect. Si no tienes ese permiso, puedes dirigir a la persona relevante a este artículo y seguir las instrucciones siguientes.

1 — Inicia sesión en App Store Connect.

2 — Seleccionar Usuarios y Acceso.

Acceso de usuario a App Store Connect

3 — Seleccionar la pestaña de Integración.

App Store Connect API Integración

4 — Haga clic en Generar API clave o en el botón de agregar (+).

Las claves de App Store Connect API crean

5 — Ingrese un nombre para la clave. El nombre es solo para su referencia y no forma parte de la clave en sí.

App Store Connect API claves crean nombre

6 — En Acceso, seleccione el rol para la clave. Los roles que se aplican a las claves son los mismos roles que se aplican a los usuarios en su equipo. Consulte permisos de rol. Recomendamos seleccionar Administrador de aplicaciones.

7 — Haz clic en Generar.

El acceso a una clave API no puede limitarse a aplicaciones específicas.

El nombre de la nueva clave, el ID de la clave, un enlace de descarga y otra información aparecen en la página.

Descargas de claves de App Store Connect

Puedes obtener toda la información necesaria aquí.
<1> ID de la incidencia.
<2> ID de la clave.
<3> Haz clic en "Descargar clave API" para descargar tu clave privada API. El enlace de descarga aparece solo si la clave privada no ha sido descargada aún. Apple no almacena una copia de la clave privada. Por lo tanto, solo puedes descargarla una vez.

🔴 Almacena tu clave privada en un lugar seguro. Nunca debes compartir tus claves, almacenar claves en un code de repositorio o incluir claves en el lado del cliente code.

Uso de una clave API de App Store Connect

El archivo de la clave API (archivo p8 que descargas), el ID de la clave y el ID del emisor son necesarios para crear el token JWT de autorización. Hay varias formas en que estos pedazos de información pueden ser introducidos en Fastlane utilizando la nueva acción de Fastlane app_store_connect_api_keyUsted puede aprender otras formas en Documentación de Fastlane. Muestro este método porque creo que es la forma más fácil de trabajar con la mayoría de las CI allí, donde puedes establecer variables de entorno.

Ahora podemos gestionar Fastlane con la clave de App Store Connect API, ¡genial!

2. Copiar archivos de Fastlane

Fastlane es una biblioteca de Ruby creada para automatizar tareas comunes de desarrollo móvil. Al utilizar Fastlane, puedes configurar

lanes

default_platform(:ios)

DEVELOPER_APP_IDENTIFIER = ENV["DEVELOPER_APP_IDENTIFIER"]
DEVELOPER_APP_ID = ENV["DEVELOPER_APP_ID"]
PROVISIONING_PROFILE_SPECIFIER = ENV["PROVISIONING_PROFILE_SPECIFIER"]
TEMP_KEYCHAIN_USER = ENV["TEMP_KEYCHAIN_USER"]
TEMP_KEYCHAIN_PASSWORD = ENV["TEMP_KEYCHAIN_PASSWORD"]
APPLE_ISSUER_ID = ENV["APPLE_ISSUER_ID"]
APPLE_KEY_ID = ENV["APPLE_KEY_ID"]
APPLE_KEY_CONTENT = ENV["APPLE_KEY_CONTENT"]
GIT_USERNAME = ENV["GIT_USERNAME"]
GIT_TOKEN = ENV["GIT_TOKEN"]

def delete_temp_keychain(name)
  delete_keychain(
    name: name
  ) if File.exist? File.expand_path("~/Library/Keychains/#{name}-db")
end

def create_temp_keychain(name, password)
  create_keychain(
    name: name,
    password: password,
    unlock: false,
    timeout: 0
  )
end

def ensure_temp_keychain(name, password)
  delete_temp_keychain(name)
  create_temp_keychain(name, password)
end

platform :ios do
  lane :build do
    build_app(
      configuration: "Release",
      workspace: "./ios/App/App.xcworkspace",
      scheme: "App",
      export_method: "app-store",
      export_options: {
        provisioningProfiles: { 
            DEVELOPER_APP_ID => "#{PROVISIONING_PROFILE_SPECIFIER}"
        }
      }
    )
  end
  lane :refresh_profiles do
    match(
      type: "development",
      force: true)
    match(
      type: "adhoc",
      force: true)
  end
  desc "Register new device"
  lane :register_new_device do  |options|
      device_name = prompt(text: "Enter the device name: ")
      device_udid = prompt(text: "Enter the device UDID: ")
      device_hash = {}
      device_hash[device_name] = device_udid
      register_devices(
                       devices: device_hash
                       )
    refresh_profiles
  end
  lane :closed_beta do
    keychain_name = TEMP_KEYCHAIN_USER
    keychain_password = TEMP_KEYCHAIN_PASSWORD
    ensure_temp_keychain(keychain_name, keychain_password)

    api_key = app_store_connect_api_key(
      key_id: APPLE_KEY_ID,
      issuer_id: APPLE_ISSUER_ID,
      key_content: APPLE_KEY_CONTENT,            
      duration: 1200,            
      in_house: false
    )

    match(
      type: 'appstore',
      git_basic_authorization: Base64.strict_encode64("#{GIT_USERNAME}:#{GIT_TOKEN}"),
      readonly: true,
      keychain_name: keychain_name,
      keychain_password: keychain_password,
      api_key: api_key
    )

    gym(
      configuration: "Release",
      workspace: "./ios/App/App.xcworkspace",
      scheme: "App",
      export_method: "app-store",
      export_options: {
        provisioningProfiles: { 
            DEVELOPER_APP_ID => "#{PROVISIONING_PROFILE_SPECIFIER}"
        }
      }
    )

    pilot(
      apple_id: "#{DEVELOPER_APP_ID}",
      app_identifier: "#{DEVELOPER_APP_IDENTIFIER}",
      skip_waiting_for_build_processing: true,
      skip_submission: true,
      distribute_external: false,
      notify_external_testers: false,
      ipa: "./App.ipa"
    )

    delete_temp_keychain(keychain_name)
  end
  lane :submit_review do
    version = ''
    Dir.chdir("..") do
      file = File.read("package.json")
      data = JSON.parse(file)
      version = data["version"]
    end
    deliver(
      app_version: version,
      submit_for_review: true,
      automatic_release: true,
      force: true, # Skip HTMl report verification
      skip_metadata: false,
      skip_screenshots: false,
      skip_binary_upload: true
    )
  end
end

personalizados que agrupan una serie de

app_identifier(ENV["DEVELOPER_APP_IDENTIFIER"])
apple_id(ENV["FASTLANE_APPLE_ID"])
itc_team_id(ENV["APP_STORE_CONNECT_TEAM_ID"])
team_id(ENV["DEVELOPER_PORTAL_TEAM_ID"])

acciones

que realizan tareas que normalmente realizarías utilizando Android Studio. Puedes hacer mucho con Fastlane, pero para los propósitos de este tutorial, utilizaremos solo una pequeña cantidad de acciones básicas. Crear un carpeta de Fastlane en la raíz de tu proyecto y copiar los siguientes archivos: Fastfile is a new approach to iOS’s code signing. Fastlane match makes it easy for teams to manage the required certificates and provisioning profiles for your iOS apps.

Crear un nuevo repositorio privado llamado certificatespor ejemplo en tu cuenta o organización GitHub personal.

Inicializar Fastlane match para tu aplicación iOS.

fastlane match init

Selecciona luego opción #1 (Almacenamiento Git).

[01:00:00]: fastlane match supports multiple storage modes, please select the one you want to use:1. git2. google_cloud3. s3?

Asigna la URL del repositorio creado recientemente.

[01:00:00]: Please create a new, private git repository to store the certificates and profiles there[01:00:00]: URL of the Git Repo: <YOUR_CERTIFICATES_REPO_URL>

Ahora tienes dentro de la carpeta de Fastlane un archivo llamado Matchfile y _git_url_context: Página/área: sitio web de marketing de Capgo. Rol: etiqueta de IU corta o elemento de navegación. Visto en: página trust.astro. Clave de mensaje `y` (Y).

# ios/Matchfilegit_url("https://github.com/gitusername/certificates")storage_mode("git")type("appstore")

debe estar configurado con la URL HTTPS del repositorio de certificados. Opcionalmente, también puedes utilizar SSH, pero requiere un paso diferente para ejecutar.

You will be prompted to enter a passphrase. Remember it correctly because it will be used later by GitHub Actions to decrypt your certificates repository.

fastlane match appstore

Se te pedirá que ingreses una contraseña. Recuerda correctamente porque se usará más tarde por __CAPGO_KEEP_0__ Acciones para descifrar tu repositorio de certificados.

[01:40:52]: All required keys, certificates and provisioning profiles are installed 🙌

Si experimentaste algún problema con GitHub y las permisos necesarios, quizás este publicación post

post

certificados y perfiles de configuración generados se suben a los recursos del repositorio de certificados project certificados de App Store Connect

Por último, abre tu

en Xcode, y actualiza el perfil de configuración de provisión para la configuración de lanzamiento de tu aplicación

certificados de XCode

Algunas cosas a tener en cuenta 💡

In GitHub, go to Configuración → Configuración del desarrollador → Tokens de acceso personal → haz clic Generate New Token → marca la casilla repo scope → haz clic luego Generate token.

Crear token de acceso personal

Tener una copia del token de acceso personal generado. Lo utilizarás más tarde para la variable de entorno GIT_TOKEN.

Luego reemplaza el archivo match generado en la carpeta de Fastlane por Matchfile

CERTIFICATE_STORE_URL = ENV["CERTIFICATE_STORE_URL"]
GIT_USERNAME = ENV["GIT_USERNAME"]
GIT_TOKEN = ENV["GIT_TOKEN"]
FASTLANE_APPLE_ID = ENV["FASTLANE_APPLE_ID"]

git_url(CERTIFICATE_STORE_URL)
storage_mode("git")
type("appstore")
git_basic_authorization(Base64.strict_encode64("#{GIT_USERNAME}:#{GIT_TOKEN}"))
username(FASTLANE_APPLE_ID)

This will be used by GitHub Actions to import the certificates and provisioning profiles. And var will be set in GitHub Secrets, instead of hard-coding them in the file.

Y la variable se establecerá en __CAPGO_KEEP_1__ Secrets, en lugar de codificarlos en el archivo.

In GitHub Actions, se le facturan según los minutos que ha utilizado para ejecutar su flujo de trabajo CI/CD. De la experiencia, tarda unos 10–15 minutos antes de que un build pueda ser procesado en App Store Connect.

Para proyectos privados, el costo estimado por build puede llegar a $0.08/min x 15 min = $1.2, o más, dependiendo de la configuración o dependencias de su proyecto.

Si comparte las mismas preocupaciones por el precio que yo para proyectos privados, puede mantener el skip_waiting_for_build_processing para true.

contexto: Página/área: Página de producto de actualizaciones en vivo. Rol: Etiqueta de IU corta o elemento de navegación. Clave de mensaje `live_update_dynamic_label_to` (Etiqueta de actualización en vivo dinámica a).

¿Qué hay de malo? Tiene que actualizar manualmente la conformidad de su aplicación en App Store Connect después de que el build ha sido procesado, para poder distribuir el build a sus usuarios. Esto es solo un parámetro opcional para actualizar si quiere ahorrar en los minutos de build para proyectos privados. Para proyectos gratuitos, esto no debería ser un problema en absoluto. Consulte.

3. Setup GitHub Actions

precios de build de nube nativa. Precio de build de nube nativa 3. Configuración de GitHub Acciones. Configuración de GitHub secretos

¿Alguna vez te has preguntado de dónde vienen los valores de los ENV no es un secreto más – provienen de tu proyecto secreto. 🤦

Establece GitHub secretos

1. APP_STORE_CONNECT_TEAM_ID - el ID de tu equipo de App Store Connect si estás en múltiples equipos.

2. DEVELOPER_APP_ID - en App Store Connect, ve al app → Información de la aplicación → Desplázate hacia abajo hasta la General Information sección de tu aplicación y busca Apple ID.

3. DEVELOPER_APP_IDENTIFIER - el identificador de paquete de tu aplicación.

4. DEVELOPER_PORTAL_TEAM_ID - el ID de tu equipo del portal de desarrolladores si estás en múltiples equipos.

5. FASTLANE_APPLE_ID - el ID de Apple o correo electrónico del desarrollador que utilizas para gestionar la aplicación.

6. GIT_USERNAME & GIT_TOKEN - Su nombre de usuario de Git y su token de acceso personal.

7. MATCH_PASSWORD - La passphrase que asignaste al inicializar Match, se utilizará para descifrar los certificados y los perfiles de provisión.

8. PROVISIONING_PROFILE_SPECIFIER - match AppStore <YOUR_APP_BUNDLE_IDENTIFIER>, por ejemplo. match AppStore com.domain.blabla.demo.

9. TEMP_KEYCHAIN_USER & TEMP_KEYCHAIN_PASSWORD - Asigna un usuario y contraseña de clave de acceso temporal para tu flujo de trabajo.

10. APPLE_KEY_ID — Conexión de App Store API Clave 🔺ID de clave.

11. APPLE_ISSUER_ID — Conexión de App Store API Clave 🔺ID de emisor.

12. APPLE_KEY_CONTENT — Conexión de App Store API Clave 🔺 Archivo de clave o contenido de clave de .p8, Verifique que esté configurado correctamente.

13. CERTIFICATE_STORE_URL — La URL del repositorio de tus claves de Match (por ejemplo: https://github.com/***/fastlane_match.git)

4. Configura el archivo de flujo de trabajo GitHub.

Crear un directorio de flujo de trabajo GitHub.

cd .github/workflows

Dentro del workflow carpeta, crea un archivo llamado build-upload-ios.ymly agrega lo siguiente.

name: Build source code on ios

on:
  push:
    tags:
      - '*'

jobs:
  build_ios:
    runs-on: macOS-latest
    steps:
      - uses: actions/checkout@v6
      - name: set Node.js
        uses: actions/setup-node@v6
        with:
          node-version: '24'
          cache: npm
      - name: Install dependencies
        id: install_code
        run: npm ci
      - name: Build
        id: build_code
        run: npm run build
      - uses: actions/cache@v5
        with:
          path: ios/App/Pods
          key: ${{ runner.os }}-pods-${{ hashFiles('**/Podfile.lock') }}
          restore-keys: |
            ${{ runner.os }}-pods-
      - name: Sync
        id: sync_code
        run: npx cap sync
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: 2.7.2
      - uses: maierj/fastlane-action@v2.3.0
        env:
          DEVELOPER_APP_IDENTIFIER: ${{ secrets.DEVELOPER_APP_IDENTIFIER }}
          DEVELOPER_APP_ID: ${{ secrets.DEVELOPER_APP_ID }}
          PROVISIONING_PROFILE_SPECIFIER: match AppStore ${{ secrets.DEVELOPER_APP_IDENTIFIER }}
          TEMP_KEYCHAIN_USER: ${{ secrets.TEMP_KEYCHAIN_USER }}
          TEMP_KEYCHAIN_PASSWORD: ${{ secrets.TEMP_KEYCHAIN_PASSWORD }}
          APPLE_ISSUER_ID: ${{ secrets.APPLE_ISSUER_ID }}
          APPLE_KEY_ID: ${{ secrets.APPLE_KEY_ID }}
          APPLE_KEY_CONTENT: ${{ secrets.APPLE_KEY_CONTENT }}
          CERTIFICATE_STORE_URL: https://github.com/${{ secrets.CERTIFICATE_STORE_REPO }}.git
          GIT_USERNAME: ${{ secrets.GIT_USERNAME }}
          GIT_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
          FASTLANE_APPLE_ID: ${{ secrets.FASTLANE_APPLE_ID }}
          MATCH_USERNAME: ${{ secrets.FASTLANE_APPLE_ID }}
          MATCH_PASSWORD: ${{ secrets.MATCH_PASSWORD }}
          APP_STORE_CONNECT_TEAM_ID: ${{ secrets.APP_STORE_CONNECT_TEAM_ID }}
          DEVELOPER_PORTAL_TEAM_ID: ${{ secrets.DEVELOPER_PORTAL_TEAM_ID }}
        with:
          lane: closed_beta
      - name: Upload release bundle
        uses: actions/upload-artifact@v2
        with:
          name: ios-release
          path: ./App.ipa
          retention-days: 60

Este flujo de trabajo debe ser desencadenado después de cada etiqueta GitHub si necesitas automatizar la etiqueta, por favor, consultaAutomatic build and release con __CAPGO_KEEP_0__ actions Automatic build and release with GitHub actions Luego, este flujo de trabajo extraerá tus dependencias de NodeJS, las instalará y construirá tu aplicación de JavaScript.

Cada vez que envíes un nuevo commit, se construirá una versión de prueba en TestFlight.

Inside the folder, create a file named __CAPGO_KEEP_0__ and add the following.

Su aplicación no necesita utilizar Ionic, solo el Capacitor base es obligatorio, puede tener un módulo de Cordova antiguo, pero el Capacitor JS plugin debería ser preferido.

5. Activar flujo de trabajo

Crear un commit

Hacer un commit, deberías ver el flujo de trabajo activo en el repositorio.

Activar el flujo de trabajo

Empujar los nuevos commits a la rama main o development Para desencadenar el flujo de trabajo.

Empezó con commit

Después de unos minutos, el build debería estar disponible en tu panel de control de App Store Connect.

Panel de pruebas de Testflight

¿Puedo desplegar desde la máquina local?

Sí, puedes, y es sencillo.

Imagina que tienes un repositorio privado, y has agotado los minutos del plan gratuito y no quieres pagar por nuevos lanzamientos, o tal vez prefieres enviar la aplicación manualmente.

Vamos a por ello

Ok, primero necesitamos crear en mi_ruta_de_proyecto/fastlane un archivo llamado .env, justo en el mismo camino que Fastfile, para poder crear el mismo clave secreta propiedades encontradas en nuestro _GitHub, a continuación:

archivo .env para desplegar desde la máquina local

Ahora, puedes ir al terminal y lanzar el Fastlane desde tu máquina:

fastlane closed_beta

❌ Lo esencial sobre el archivo .env ya que preferimos no exponer esta información, debemos agregarlo en nuestro archivo .gitignore, algo así: ❌

fastlane/*.env

Debería funcionar de la misma manera que sucede desde GitHub Acciones en la máquina remota, pero en nuestra máquina local. 🍻

Correr Fastlane local

Ejecución en Terminal: $ Fastlane closed_beta

Si has llegado hasta aquí, mi felicitación, ahora tienes un proceso automatizado completo para tus aplicaciones iOS con Fastlane y GitHub Acciones.

Cada vez que envíes un nuevo commit, se construirá una versión en el console de Google Play, canal beta. Me mejoraré este blog con tus retroalimentaciones, si tienes alguna pregunta o sugerencia, por favor házmelo saber por correo electrónico martin@capgo.app

Construir en tu dispositivo

Si todavía necesitas construir en tu dispositivo, debes agregarlos manualmente a la configuración de provisión. Conecta tu dispositivo a tu Mac y abre el menú de dispositivo encontrar dispositivo ios menú Luego copia tu identificador encontrar identificador ios Y luego inicia el comando: fastlane register_new_device te pedirá que establezcas un nombre de dispositivo y el identificador: establecer identificador ios

si tienes problemas

Si tienes problemas con el dispositivo de desarrollo que no puedes probar, etc., lo que suele solucionarlo.

Hay un comando mágico que puede salvarte:

fastlane match nuke development
fastlane match development

Luego: Limpia el proyecto manteniendo presionada la tecla Shift(⇧)+Command(⌘)+K o seleccionando Product > Limpia (podría estar etiquetado como “Limpia carpeta de compilación”)

Luego intenta ejecutar de nuevo la aplicación en tu dispositivo.

Gracias

Este blog se basa en los siguientes artículos:

Keep going from Automatic Capacitor IOS build with GitHub actions using match

Si estás utilizando Automatic Capacitor IOS build with GitHub actions using match Para planificar la automatización de CI/CD, conecta con Capgo CI/CD para el flujo de trabajo del producto en Capgo CI/CD, Capgo Construcción nativa para el flujo de trabajo del producto en Capgo Construcción nativa, Capgo Integraciones para el flujo de trabajo del producto en Capgo Integraciones, Integración de CI/CD para los detalles de implementación en la Integración CI/CD, y GitHub Integración de Acciones para los detalles de implementación en GitHub Integración de Acciones.

Construcción automática de IOS con Capacitor utilizando acciones de GitHub con match