Crea una canalización de entrega para dispositivos móviles sin servidores

En este instructivo, se describe cómo crear una canalización de entrega para dispositivos móviles sin servidores en Google Cloud:

  • Primero, te guía en la configuración de una aplicación para Android de prueba que puedes compilar y distribuir con los comandos Gradle en tu máquina local. Con estos comandos, se crea el paquete de aplicación para Android (APK) y se lo sube a Firebase App Distribution con el fin de distribuirlo a los verificadores Beta.
  • A continuación, a fin de automatizar este proceso, instala el compilador de Android para Cloud Build y configura un activador de compilación, de modo que se active la compilación y distribución de la aplicación para Android de forma automática con cambios en su código fuente.

Objetivos

  • Crear una tarea de compilación que compile un APK firmado
  • Crear una tarea de compilación que use Firebase App Distribution para distribuir compilaciones nuevas
  • Instalar el compilador de Android con las dependencias del SDK de Android requeridas
  • Crear un activador de compilación en Google Cloud que use el compilador de Android para compilar el APK firmado y distribuirlo con Firebase App Distribution

Costos

En este instructivo, se usan componentes facturables de Google Cloud, incluidos los siguientes:

La imagen base del compilador de Android es de alrededor de 1.9 GB. La Calculadora de precios estima que el costo de almacenamiento de un entorno de 2 GB es de alrededor de $0.05 por mes. La compilación de la imagen base del compilador de Android demora alrededor de 11 minutos y cuesta $0.03. Cada compilación adicional debería tomar alrededor de 5 minutos y costar $0.02. Consulta los precios de Cloud Build para obtener más información.

Antes de comenzar

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyecto

  3. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

  4. Habilita la API Compute Engine.

    Habilita la API

  5. Instala e inicializa el SDK de Cloud.
  6. Asegúrate de tener Gradle instalado en tu computadora.
  7. Asegúrate de tener Android Studio instalado en tu computadora.
  8. Asegúrate de que Git esté instalado en tu computadora.

En este instructivo se supone lo siguiente:

  • Ejecutas macOS o Linux. Algunos de estos procedimientos se pueden adaptar a un entorno de Windows, pero el instructivo no proporciona instrucciones completas para ese caso práctico.
  • Estás familiarizado con el desarrollo de Android, Android Studio, Gradle y Git.

Haz que la compilación Beta de Android firmada trabaje de forma local

En esta sección, configurarás una aplicación para Android de prueba en Android Studio. La aplicación se puede compilar y distribuir mediante las tareas de compilación de Gradle que se ejecutan en la ventana de la terminal de tu computadora.

Crea una aplicación para Android de prueba a fin de compilarla

  1. En Android Studio, crea un proyecto de Android nuevo que use una actividad vacía.

    En las capturas de pantalla siguientes, se muestran los pasos del asistente para realizar esta tarea.

    Asistente de Android Studio, página 1

    Asistente de Android Studio, página 2

    Asistente de Android Studio, página 3

    Asistente de Android Studio, página 4

  2. Desde la ventana de la terminal en tu computadora, cambia al directorio en el que creaste tu aplicación de prueba:

    cd ${HOME}/android-apps/TestAndroidBuild
  3. En ese directorio, inicializa un repositorio de Git:

    git init && git checkout -b develop
  4. Edita el archivo .gitignore y agrega los nombres de archivos y extensiones que Git no debe enviar a tu repositorio del código fuente:

    cat >> .gitignore <<EOF
    google-services.json
    app-distro.json
    keystore.properties
    EOF
  5. Confirma la aplicación en el repositorio:

    git add -A
    git commit -m "empty application"
  6. Configura la herramienta de línea de comandos de gcloud para usar tu proyecto. Para [PROJECT_NAME], usa el nombre del proyecto que seleccionaste o creaste.

    PROJECT=[PROJECT_NAME]
    gcloud config configurations create $PROJECT
    gcloud config config set project $PROJECT
  7. Crea un repositorio de Cloud Source Repositories para tu aplicación para Android:

    gcloud source repos create android-application
  8. Agrega el repositorio de Cloud Source Repositories como un repositorio remoto de tu aplicación para Android:

    git remote add google \
        https://source.developers.google.com/p/${PROJECT}/r/android-application

Agrega Firebase a tu aplicación

  1. Ve a Firebase console:

    Ir a Firebase console

  2. Haz clic en Agregar proyecto.

  3. En Ingresa el nombre de tu proyecto (Enter your project name), selecciona el proyecto de Google Cloud que creaste antes:

    Menú de proyecto de Firebase Cloud.

  4. Confirma el plan de facturación Blaze de Firebase.

  5. Selecciona si deseas habilitar Google Analytics. Para este instructivo, no necesitas usar Analytics.

  6. Espera a que se cree el proyecto Firebase y, luego, haz clic en Continuar.

  7. Sigue las instrucciones de la página sobre cómo agregar Firebase al proyecto de Android a fin de agregar Firebase a tu aplicación para Android.

  8. Asegúrate de que tu archivo google-services.json se movió al siguiente directorio:

    {HOME}/android-apps/TestAndroidBuild

  9. Sigue las instrucciones de la página sobre cómo comenzar a usar Firebase Crashlytics para agregar Firebase Crashlytics a tu proyecto de Android.

  10. Cambia los directorios al directorio de nivel de la app de tu proyecto:

    cd {HOME}/android-apps/TestAndroidBuild/app

  11. Crea una cuenta de servicio de Google Cloud con la función de administrador de Firebase:

    gcloud iam service-accounts create app-distro --display-name=app-distro
    APP_DISTRO_SA=$(gcloud iam service-accounts list --filter="displayName:app-distro" --format='value(email)')
    gcloud projects add-iam-policy-binding $PROJECT --role roles/firebase.admin --member serviceAccount:$APP_DISTRO_SA
    gcloud iam service-accounts keys create app-distro.json $APP_DISTRO_SA
    

Crea la clave de firma y el almacén de claves

Si deseas distribuir la aplicación para Android previo al lanzamiento, debes firmar la aplicación con un certificado almacenado en un archivo de almacén de claves (.jks) de Java.

  1. En la ventana de la terminal, cambia al directorio superior de tu aplicación:

    cd ${HOME}/AndroidStudioProjects/TestAndroidBuild
  2. Crea el almacén de claves y la clave de Java a fin de firmar la aplicación, también crea el archivo keystore.properties que almacena el alias de la clave, la contraseña y la ruta relativa para el archivo del almacén de claves:

    JKS_PASSWORD=$(openssl rand -base64 12)
    keytool -genkey -noprompt -keystore ../signing/android.jks \
      -alias android-key \
      -dname "CN=example.com, OU=IT, O=Example, L=Sunnyvale, S=California, C=US" \
      -storepass ${JKS_PASSWORD} \
      -keypass ${JKS_PASSWORD}
    
    cat > ../signing/keystore.properties <<EOF
    storeFile=../signing/android.jks
    storePassword=${JKS_PASSWORD}
    keyPassword=${JKS_PASSWORD}
    keyAlias=android-key
    EOF

Encripta los archivos de secretos de Android y agrégalos a tu repositorio de código fuente.

  1. Habilita el servicio de administración de claves:

    gcloud services enable cloudkms.googleapis.com
    
  2. Crea un llavero de claves para almacenar tus claves:

    gcloud kms keyrings create my-app --location=global
    
  3. Crea una clave para almacenar tus secretos:

    gcloud kms keys create android-builder \
        --location=global \
        --keyring=my-app \
        --purpose=encryption
    
  4. Agrega la función de encriptación y desencriptación a la cuenta de servicio de Cloud Build:

    CLOUDBUILD_ACCOUNT=$(gcloud projects get-iam-policy $PROJECT \
        --filter="(bindings.role:roles/cloudbuild.builds.builder)" \
        --flatten="bindings[].members" \
        --format="value(bindings.members[])" | tail -1)
    
    gcloud kms keys add-iam-policy-binding android-builder --location=global \
        --keyring=my-app --member="${CLOUDBUILD_ACCOUNT} \
        --role=roles/cloudkms.cryptoKeyEncrypterDecrypter
    
  5. Encripta el archivo keystore.properties:

    gcloud kms encrypt --plaintext-file=signing/keystore.properties \
        --ciphertext-file=signing/keystore.properties.enc --location=global \
        --keyring=my-app --key=android-builder
    
  6. Agrega los archivos de firma a tu repositorio de código fuente:

    git add signing
    git commit -m "encrypted signing information"
    
  7. Encripta el archivo google-services.json:

    gcloud kms encrypt --plaintext-file=app/google-services.json \
        --ciphertext-file=app/google-services.json.enc --location=global \
        --keyring=my-app --key=android-builder
    
  8. Agrega el archivo google-services.json.enc a tu repositorio de código fuente:

    git add app/google-services.json.enc
    git commit -m "encrypted application account"
    
  9. Encripta el archivo app-distro.json:

    gcloud kms encrypt --plaintext-file=app-distro.json \
        --ciphertext-file=app-distro.json.enc \
        --location=global \
        --keyring=my-app --key=android-builder
    
  10. Agrega el archivo app-distro.json.enc a tu repositorio de código fuente:

    git add app-distro.json.enc
    git commit -m "encrypted service account"
    

Agrega Firebase App Distribution

Crea un grupo de distribución de Firebase

  1. Ve a Firebase console:

    Ir a Firebase console

  2. Haz clic en la app que creaste para Firebase. El nombre es similar al nombre del proyecto de Cloud.

  3. Haz clic en Distribución de la app.

  4. Haz clic en Verificadores.

  5. Haz clic en Agregar verificadores.

  6. Ingresa tu dirección de correo electrónico.

  7. Haz clic en Crear un grupo de verificadores.

  8. Ingresa el nombre beta-testers.

  9. Haz clic en Agregar verificadores.

  10. Agrega tu dirección de correo electrónico al grupo beta-testers.

Actualiza el archivo build.gradle de modo que incluya las opciones de configuración de la firma y distribución de Firebase.

  1. Actualiza el archivo {HOME}/AndroidStudioProjects/TestAndroidBuild/build.gradle con las líneas en negrita debajo:

    buildscript {
        ext.kotlin_version = '1.3.41'
        repositories {
            google()
            jcenter()
        }
        dependencies {
            classpath 'com.android.tools.build:gradle:3.5.0'
            classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version'
            classpath 'com.google.firebase:firebase-appdistribution-gradle:2.0.0'
            classpath 'com.google.gms:google-services:4.3.1'
            // NOTE: Do not place your application dependencies here; they belong
            // in the individual module build.gradle files
        }
     }
    
  2. Agrega los fragmentos siguientes al archivo {HOME}/AndroidStudioProjects/TestAndroidBuild/app/build.gradle:

    android {
    // ...
    def debugKeystorePropertiesFile = rootProject.file("signing/keystore.properties")
    def keystoreProperties = new Properties()
    keystoreProperties.load(new FileInputStream(debugKeystorePropertiesFile))
    //...
    android {
      //...
        signingConfigs {
           debug {
            keyAlias keystoreProperties['keyAlias']
            keyPassword keystoreProperties['keyPassword']
            storeFile file(keystoreProperties['storeFile'].trim())
            storePassword keystoreProperties['storePassword']
          }
         }
          buildTypes {
            debug {
              firebaseAppDistribution {
                releaseNotesFile="release-notes.txt"
                groups="beta-testers"
              }
            }
          // ...
            packagingOptions {
              exclude "app-distro.json"
            }
          }
      }
    

Corrige la dependencia de prueba en el archivo de Gradle

  1. Asegúrate de que la línea en negrita siguiente esté en tu archivo ${HOME}/AndroidStudioProjects/TestAndroidBuild/app/build.gradle:

    dependencies {
      //...
      androidTestImplementation 'androidx.test:runner:1.2.0'
      androidTestImplementation 'androidx.test.ext:junit:1.1.1'
      androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
     }
    

Compila y distribuye la app desde tu computadora

  1. En la ventana de la terminal, asegúrate de estar en el directorio superior para tu aplicación de prueba:

    {HOME}/AndroidStudioProjects/TestAndroidBuild

  2. Compila y distribuye la app:

    gradle assembleDebug appDistributionUploadDebug
    

    Se envía un correo electrónico al grupo de distribución con un vínculo que permite al usuario instalar la aplicación.

Guarda los cambios de la compilación en el repositorio de código fuente

  • Confirma tus cambios al repositorio de código fuente:

    git add app/build.gradle && git commit -m "Update build for distribution."
    

Crea tu compilación de Android en Cloud Build

En este punto, tienes tareas de compilación de Gradle que compilan y distribuyen tu aplicación para Android. En esta sección, configurarás Cloud Build para que ejecute estas tareas de compilación cada vez que haya un cambio en la rama de la instancia principal del Cloud Source Repository.

  1. Establece la variable de entorno PROJECT:

    export PROJECT=$(gcloud config get-value project)
    
  2. Crea el bucket de almacenamiento que usará el compilador de Android para guardar sus dependencias entre las compilaciones:

    gsutil mb gs://$PROJECT-cache-bucket
    
  3. Crea el bucket de almacenamiento que usará el compilador de Android para aumentar la cantidad de compilaciones de Android:

    gsutil mb gs://$PROJECT-config-bucket
    
  4. Crea el bucket de almacenamiento que usará el compilador de Android para almacenar artefactos:

    gsutil mb gs://$PROJECT-artifact-bucket
    

Crea el compilador de Android

  1. En una ventana de la terminal, clona el repositorio de compiladores de comunidad en un directorio fuera del directorio de tu aplicación para Android:

    git clone https://github.com/GoogleCloudPlatform/cloud-builders-community
    

    El repositorio de GitHub contiene los compiladores mantenidos por la comunidad.

  2. Cambia al directorio que contiene el compilador tar:

    cd cloud-builders-community/tar
    
  3. Agrega el compilador tar a tu proyecto:

    gcloud builds submit --config=cloudbuild.yaml
    
  4. Cambia al directorio que contiene el compilador de Android:

    cd ../android
    
  5. Crea el compilador de Android y pasa la versión del SDK de destino como una sustitución:

    gcloud builds submit --config=cloudbuild.yaml \
        --substitutions=_ANDROID_VERSION=28 

Crea el activador de compilación de la aplicación para Android

En esta sección, crearás el activador de compilación de la aplicación que usa el compilador de Android de la sección anterior con el fin de compilar y distribuir la aplicación para Android.

  1. En la ventana de la terminal, copia el archivo de ejemplo cloudbuild.yaml desde el directorio examples/ del compilador de Android en el directorio de tu aplicación para Android de prueba:

    cd ${HOME}/android-apps/TestAndroidBuild
    cp ${HOME}/cloud-builders-community/android/examples/build-test-deploy-firebase-distro.yaml \ ./cloudbuild.yaml
    
  2. Agrega el nuevo archivo cloudbuild.yaml a la rama develop de tu repositorio de código fuente:

    git add cloudbuild.yaml && git commit -m "Add android builder to project."
    
  3. En Cloud Console, ve a la página de Activadores de compilación:

    Ir a la página de Activadores de compilación

  4. Haz clic en Crear activador.

  5. Selecciona el repositorio android-application.

  6. En Nombre, ingresa android-application-build.

  7. En Configuración de compilación, selecciona cloudbuild.yaml.

  8. En Ubicación de cloudbuild.yaml , ingresa /cloudbuild.yaml.

  9. Haz clic en Agregar elemento. Esto te permite establecer variables para la compilación.

  10. Para cada variable de la siguiente tabla, ingresa el nombre de variable (incluido el guión bajo inicial) y, luego, el valor de tu proyecto.

    Variable Valor Propósito
    _CONFIG_BUCKET
    El depósito usado para almacenar el número de compilación.
    gs://[PROJECT_NAME]-config-bucket La URL del bucket que se usará para almacenar el número de compilación.
    _CACHE_BUCKET
    El depósito que se usará para almacenar en caché las dependencias de compilación.
    gs://[PROJECT_NAME]-cache-bucket Evita que Gradle descargue las mismas dependencias de Internet con cada compilación.
    _ARTIFACT_BUCKET
    El depósito de Cloud Storage usado para almacenar artefactos de compilación.
    gs://[PROJECT_NAME]-artifact-bucket El compilador de Android almacena aquí artefactos intermedios y de otro tipo durante la compilación.
  11. Haz clic en Crear activador.

Ejecuta el activador de compilación de la aplicación

Ahora, puedes probar que el activador de compilación de la aplicación funciona y confirmar que la aplicación se distribuye a tu correo electrónico.

  1. En una ventana de la terminal, cambia los directorios al directorio de nivel superior de tu proyecto de la aplicación para Android de prueba:

    cd ${HOME}/android-apps/TestAndroidBuild
  2. Para activar la compilación, envíala a la rama de la instancia principal del repositorio del código fuente:

    git push google develop
  3. En Cloud Console, ve a la página de Cloud Build.

  4. Haz clic en la última compilación en progreso para ver el resultado de la compilación de la aplicación.

Limpieza

Una vez que hayas terminado el instructivo, debes limpiar los recursos que creaste en Google Cloud para que no se te facturen en el futuro. En las secciones siguientes, se describe cómo borrar o desactivar estos recursos.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, sigue estos pasos:

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Borra registros de imágenes

Borra los registros de imágenes de tu imagen del SDK de Android y la imagen de la aplicación para Android.

  1. En el menú de navegación a la izquierda en Cloud Console, desplázate a la sección Herramientas y haz clic en Container Registry > Imágenes (Images).
  2. Selecciona todas las imágenes.

    Selección de todas las imágenes

  3. Haz clic en Borrar (Delete).

Borra depósitos de Cloud Storage

Borra los depósitos de Cloud Storage que contengan la información de firma de Android y las propiedades de Fabric. En Cloud Shell, usa estos comandos y sustituye tus valores por los marcadores de posición:

  1. Configura la variable de entorno PROJECT.

    export PROJECT=$(gcloud config get-value project)
    
  2. Borra los depósitos de almacenamiento creados para la compilación.

    gsutil rm gs://$PROJECT-cache-bucket
    gsutil rm gs://$PROJECT-config-bucket
    gsutil rm gs://$PROJECT-artifact-bucket
    

Borra los activadores de compilación

  1. Borra el activador de compilación base del SDK de Android.
  2. Borra el activador de compilación de Android.

Borra la aplicación de Firebase

  1. Ve a Firebase console.

  2. Selecciona el proyecto de Firebase que creaste para el instructivo. Debe tener un nombre similar a [PROJECT_NAME].

  3. En el menú de configuración, selecciona Configuración del proyecto (Project Settings). Configuración del proyecto de Firebase

  4. Desplázate hasta la parte inferior de la página y haz clic en Borrar proyecto.

¿Qué sigue?