Automaticos de iOS con GitHub acciones utilizando Match

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

Recomendado para Nuevas Construcciones: Utilice Capgo Build

Ahora recomendamos utilizar Capgo Construcción con el Capgo CLI para compilaciones nativas Capacitor. Esta guía de Fastlane Match se mantiene para los equipos que mantienen existentes pipelines de acciones GitHub, pero los nuevos compilados de iOS deben utilizar el Capgo CLI para que no deban mantener repositorios de Fastlane, Match, ejecutores de Xcode, certificados y scripts de carga por sí mismos.

Capgo Build para CI/CD por Capgo

Evite la mantenimiento de Fastlane Match, ejecutor de Xcode, certificado, perfil de provisión y script de carga. Capgo Construcción Ejecuta compilaciones nativas de iOS firmadas desde tu pipeline de CI/CD existente:

Funciona con tu pipeline: Desencadé Capgo Build desde acciones GitHub, GitLab CI, Jenkins o scripts locales después de tu compilación web y npx cap sync.
Firma desde secretos de CI: Mantenga las llaves de App Store Connect, certificados, perfiles de provisión, contraseñas y IDs de equipo en tus propios secretos de CI.
No hay mantenimiento de ejecutor nativo: Capgo Build proporciona entornos de compilación Apple mantenidos, por lo que no debes administrar ejecutores de macOS, imágenes de Xcode, Fastlane o repositorios de Match.
Artículos y presentación: Descargar artefactos firmados para QA o presentar builds de liberación a través del Capgo CLI.

Precio

Plan Capgo comienza en $12/mes
Incluye actualizaciones OTA y aproximadamente 15 compilaciones nativas por mes
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úrese de tener instalado Fastlane instalado en su máquina de desarrollo.
miembro del programa de desarrolladores de iOS.
Deseo de leer 😆…
Un equipo de muchos devs, en caso contrario 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.
We vamos a utilizar un macOS máquina, puedes ver en la captura su precio y límites (precios a la fecha de creación del tutorial, pueden sufrir cambios en el futuro)

🔴 Una vez advertido de los requisitos y precios, si te gusta, continuamos…

📣 En el post asumimos que tenemos la aplicación creada en iTunes Connect, tenemos los certificados del ecosistema de Apple, todo se copiará con 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
Configura Fastlane match

1. Usando App Store Connect API con Fastlane Match

Desde el 1 de 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 tu ID de Apple ayuda a asegurarte de que eres la única persona que puede acceder a tu cuenta.
Desde Soporte de Apple

Para empezar a usar match debes revocar tus certificados existentes. Pero no te preocupes, tendrás el nuevo directamente.

Requisitos

Para poder usar App Store Connect API, Fastlane necesita tres ID del emisor.

ID de la clave.
ID de la clave.
Archivo de clave o contenido de clave.

Crear una clave de App Store Connect API.

Para generar claves, debe tener permiso de Administrador en App Store Connect. Si no tiene ese permiso, puede dirigir a la persona relevante a este artículo y seguir las instrucciones siguientes.

1 — Inicie sesión en App Store Connect.

2 — Seleccione Usuarios y Acceso.

Acceso de usuario de App Store Connect

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

Integración de App Store Connect API

4 — Haz clic en Generar llave API o en el botón (+).

Las claves de App Store Connect API crean

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

App Store Connect API claves crear nombre

6 — En Acceso, selecciona el rol para la clave. Los roles que se aplican a las claves son los mismos roles que se aplican a los usuarios de tu equipo. Consulta permisos de rol. Recomendamos seleccionar App manager.

7 — Haz clic en Generar.

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

El nombre de la nueva clave, el ID de clave, un enlace de descarga y otros detalles aparecen en la página.

App Store Connect descargar claves

Puedes obtener toda la información necesaria aquí.
<1> Identificador de la incidencia.
<2> Identificador de clave.
<3> Haga clic en “Descargar API Clave” para descargar su API clave privada. El enlace de descarga aparece solo si la clave privada no se ha descargado aún. Apple no almacena una copia de la clave privada. Por lo tanto, solo puede descargarla una vez.

🔴 Almacene su clave privada en un lugar seguro. Nunca debe compartir sus claves, almacenar claves en un code repositorio o incluir claves en el lado del cliente code.

Usando una Clave API de App Store Connect

El archivo de la Clave API (archivo p8 que descargó), el identificador de clave y el identificador del emisor son necesarios para crear el token JWT de autorización. Hay varias formas en que estos elementos de información se pueden ingresar en Fastlane utilizando la nueva acción de Fastlane app_store_connect_api_key. 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, donde puede establecer variables de entorno.

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

2. Copiar archivos de Fastlane

Fastlane es una biblioteca de Ruby creada para automatizar tareas comunes de desarrollo móvil. Utilizando Fastlane, puede configurar “carriles” personalizados que agrupan una serie de “acciones” que realizan tareas que normalmente realizaría utilizando Android Studio. Puede hacer mucho con Fastlane, pero para los propósitos de este tutorial, solo utilizaremos una pequeña cantidad de acciones básicas.

Cree un folder de Fastlane en la raíz de su proyecto y copie los siguientes archivos: Fastfile

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

Appfile

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"])

Configura Fastlane match

Fastlane match 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 repositorio privado con el nombre certificatespor ejemplo, en su cuenta personal o organización de GitHub.

Inicializar Fastlane match para su aplicación de iOS.

fastlane match init

Luego seleccione la 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?

Asigne 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 tiene dentro del folder de Fastlane un archivo con el nombre Matchfile y _git_url_debe configurarse con la URL HTTPS del repositorio de certificados. Opcionalmente, también se puede utilizar SSH, pero requiere un paso diferente para ejecutar.

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

Enseguida, vamos a generar los certificados y ingresar nuestros credenciales cuando se nos pregunte con Fastlane Match.

Se le pedirá que ingrese una contraseña. Recuerde correctamente porque se utilizará más tarde por las Acciones de GitHub para descifrar su repositorio de certificados.

fastlane match appstore

Si todo salió bien, debería ver algo así:

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

Si experimentó algún problema con GitHub y los permisos necesarios, quizás esta publicación le ayudará a generar tokens de autenticación para Git.

Certificados y perfiles de configuración generados se suben a los recursos del repositorio de certificados

Certificados de App Store Connect

Finalmente, abra su project actualice el perfil de provisión en Xcode para la configuración de lanzamiento de su aplicación.

Certificados de XCode

Algunas cosas a tener en cuenta 💡

MATCH

Para que la CI/CD importe los certificados y perfiles de configuración, necesita tener acceso al repositorio de certificados. Puede hacer esto generando un token de acceso personal (que debe haber utilizado antes) que tenga el alcance para acceder o leer repositorios privados.

En GitHub, vaya a Configuración → Configuración de desarrollador → Tokens de acceso personal → haga clic Generate New Token → marque la repo scope → luego haga clic Generate token.

Crear token de acceso personal

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

Reemplaza luego tu archivo de 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)

Se utilizará por GitHub Acciones para importar los certificados y perfiles de configuración. Y la variable se establecerá en GitHub Secretos, en lugar de codificarlos en el archivo

Procesamiento de construcción

En GitHub Acciones, se te facturará según los minutos que hayas utilizado para ejecutar tu flujo de trabajo de CI/CD. De la experiencia, tarda unos 10–15 minutos antes de que una construcción pueda ser procesada en App Store Connect

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

Si compartes las mismas preocupaciones por el precio como yo para proyectos privados, puedes mantener el skip_waiting_for_build_processing para true.

What’s the catch? You have to manually update the compliance of your app in App Store Connect after the build has been processed, for you to distribute the build to your users.

Este es un parámetro opcional para actualizar si deseas ahorrar minutos de construcción para proyectos privados. Para proyectos gratuitos, esto no debería ser un problema en absoluto. Consulta precios.

3. Configura GitHub Acciones

Configura GitHub secretos

¿Dónde se encuentran los valores de los ENV Esto no es un secreto más – proviene 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 aplicación → 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 - tu identificador de paquete de aplicación.

4. DEVELOPER_PORTAL_TEAM_ID - el ID de tu equipo de Portal de Desarrolladores si perteneces a varios equipos.

5. FASTLANE_APPLE_ID - the Apple ID or developer email you use to manage the app.

6. GIT_USERNAME & GIT_TOKEN Tu nombre de usuario de Git y tu token de acceso personal.

7. MATCH_PASSWORD - la passphrase que asignaste al inicializar match, se utilizará para descifrar los certificados y perfiles de configuración.

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

9. TEMP_KEYCHAIN_USER & TEMP_KEYCHAIN_PASSWORD - asigna un usuario y contraseña de keychain temporal para tu flujo de trabajo.

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

11. APPLE_ISSUER_ID — Conexión de Tienda de App API Clave 🔺ID de Emisor.

12. APPLE_KEY_CONTENT — App Store Connect API Clave 🔺 Archivo de clave o contenido de clave .p8, revisarlo

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

4. Configure GitHub workflow file

Crear un directorio de flujo de trabajo GitHub.

cd .github/workflows

Dentro de workflow y agregar lo siguiente. build-upload-ios.ymly agregar 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 debería ser desencadenado después de cada GitHub tagSi necesitas automatizar la etiqueta, por favor, consulta Construcción y lanzamiento automático con acciones de GitHub primero.

Luego, este flujo de trabajo extraerá sus dependencias de NodeJS, las instalará y construirá su aplicación de JavaScript.

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

No es necesario que su aplicación utilice Ionic, solo es necesario que tenga la base de Capacitor como requisito, puede tener módulos de Cordova antiguos, pero se recomienda utilizar el plugin de JavaScript Capacitor.

5. Activar el flujo de trabajo

Crear un commit

Hacer un commitDeberías ver el flujo de trabajo activo en el repositorio.

Activar el flujo de trabajo

Push los nuevos commits a la rama main o development para desencadenar el flujo de trabajo.

Empezado con el commit

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

Panel de control de Testflight

Puede desplegar desde la máquina local?

Sí, puede hacerlo, y es sencillo.

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

Vamos por ello

Ok, primero debemos crear en mi_proyecto_path/fastlane ruta a un archivo llamado .env, exactamente en la misma ruta que Fastfile, para poder crear las mismas secret propiedades encontradas en nuestro _GitHub, a continuación:

Archivo .env para desplegar desde la máquina local

Ahora, puedes ir a la y lanzar el y lanzar el Fastfile desde tu máquina:

fastlane closed_beta

❌ Esencial sobre el .env archivo, ya que preferimos no exponer esta información, debemos agregarla en nuestro .gitignorearchivo, algo así:

fastlane/*.env

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

Ejecución local de Fastlane

Ejecución de terminal: $ Fastlane closed_beta

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

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

Construye en tu dispositivo

Si todavía necesitas construir en tu dispositivo, debes agregarlos manualmente a la configuración de provisión. encontrar dispositivo menú iOS Encuentra el menú de dispositivos iOS Luego copia tu identificador Encuentra el identificador de iOS fastlane register_new_device Te pedirá que establezcas un nombre de dispositivo y el identificador. establecer identificador ios

Establece el identificador de iOS

Si tienes un problema con el dispositivo de desarrollo que no puede probar, etc., eso suele solucionarlo.

Hay una mágica comando que puede salvar a usted:

fastlane match nuke development
fastlane match development

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

Intenta ejecutar la aplicación nuevamente en tu dispositivo.

Gracias

Este blog se basa en los siguientes artículos:

Siga adelante desde la construcción automática de IOS Capacitor con GitHub acciones utilizando match

Si está utilizando Construcción automática de IOS Capacitor con GitHub acciones utilizando match para planificar la automatización de CI/CD, conecte con Capgo CI/CD para el flujo de trabajo del producto en Capgo CI/CD, Capgo Compilaciones nativas para el flujo de trabajo del producto en Capgo Compilaciones nativas Capgo Integraciones para el flujo de trabajo del producto en Capgo Integraciones Integración CI/CD para el detalle de implementación en Integración CI/CD, y GitHub Integración de Acciones para el detalle de implementación en GitHub Integración de Acciones

Automatic Capacitor IOS build con GitHub acciones utilizando match