Play Store पर Android ऐप बंडल को स्वचालित रूप से कैसे अपलोड करें

इस लेख में, मैं यह समझाने जा रहा हूं कि Play Store के बीटा ट्रैक पर Android ऐप बंडल (.aab फ़ाइल) को स्वचालित रूप से कैसे अपलोड किया जाए। हम Android Studio और AWS को क्लाउड इंफ्रास्ट्रक्चर प्रदाता के रूप में उपयोग करेंगे।

ऐप बंडल अपलोड करने के बाद, हम एक स्लैक नोटिफिकेशन ट्रिगर करेंगे।

यह कई कारणों से आपके समय का एक मूल्यवान उपयोग है, जैसे अवलोकन योग्यता बनाना और प्रक्रियाओं को प्राथमिकता देना।

तकनीक हम उपयोग करेंगे

यहां वे संसाधन हैं जिनका उपयोग हम इस ट्यूटोरियल के लिए करने जा रहे हैं:

1. एंड्रॉइड स्टूडियो
2. एडब्ल्यूएस कोडबिल्ड
3. एडब्ल्यूएस लैम्ब्डा
4. S3
5. सुस्त

परियोजना का उच्च स्तरीय अवलोकन

ऊपर दी गई छवि आपको एक सामान्य अवलोकन दिखाती है कि हम पूरी चीज़ की संरचना कैसे करेंगे।

अनिवार्य रूप से, आपके Android रिपॉजिटरी के लिए AWS पर एक कोड पाइपलाइन स्थापित करने की आवश्यकता है। इस कोड पाइपलाइन में कोड बिल्ड इसके एक चरण के रूप में होगा।

आपके एंड्रॉइड ऐप रिपॉजिटरी की मास्टर ब्रांच पर पुश करने से कोड बिल्ड ट्रिगर होगा। कोड बिल्ड प्रोजेक्ट कमांड लाइन से एंड्रॉइड ऐप पर हस्ताक्षर करेगा और आर्टिफैक्ट को S3 बकेट में अपलोड करेगा।

बंडल को S3 पर अपलोड करने से एक लैम्ब्डा ट्रिगर होगा, जो बंडल को डाउनलोड करेगा और Google प्रकाशन API का उपयोग करके इसे Play Store पर अपलोड करेगा। एक बार 200 प्रतिक्रिया मिलने के बाद, लैम्ब्डा एक स्लैक अधिसूचना को ट्रिगर करेगा।

अपनी Google Play सेवा खाता कुंजी कैसे प्राप्त करें

Google Play प्रकाशक API का उपयोग करने में सक्षम होने के लिए, आपको Google Play सेवा खाता कुंजी की आवश्यकता होगी।

एक सेवा खाता एक ऐसा खाता है जो आपकी ओर से तब कार्य कर सकता है जब सर्वर एक दूसरे के साथ संचार कर रहे हों। आप इस बारे में अधिक पढ़ सकते हैं कि Google सर्वर से सर्वर संचार के लिए OAuth2.0 का उपयोग कैसे करता है।

यह देखने के लिए कि सेवा खाता कैसे बनाया जाए और उसे Google Play प्रकाशक API तक पहुंच प्रदान की जाए, यहां देखें।

एक बार जब आप अपना सेवा खाता बना लेते हैं और उसे उपयुक्त अनुमतियाँ दे देते हैं, तो सेवा खाता कुंजी डाउनलोड करना और उसे सुरक्षित रखना सुनिश्चित करें। आप इसे जल्द ही एक S3 बकेट में अपलोड करेंगे।

Android बंडल पर हस्ताक्षर कैसे करें

समझने वाली मुख्य बात यह है कि Android ऐप बंडल पर हस्ताक्षर कैसे करें। Google के पास इस पर काफी अच्छे दस्तावेज़ हैं जो आपको यहां मिल सकते हैं।

मैं नीचे दिए गए लिंक को संक्षेप में बताऊंगा।

keytool . का उपयोग करके एक निजी कुंजी जेनरेट करें इस तरह:

keytool -genkey -v -keystore my-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias my-alias

आप अपनी चाबी को जो चाहें कॉल कर सकते हैं। यहाँ, मैंने इसे my-release-key.jks कहा है . आप जो भी उपनाम चाहते हैं उसे भी चुन सकते हैं। इस पूरे ट्यूटोरियल में अपनी कुंजी के लिए सही नाम और उपनाम का उपयोग करना सुनिश्चित करें।

build.gradleखोलें आपके app . के अंदर Android Studio में निर्देशिका और इसमें निम्न कोड ब्लॉक जोड़ें:

android {
    ...
    defaultConfig { ... }
    signingConfigs {
        release {
            // You need to specify either an absolute path or include the
            // keystore file in the same directory as the build.gradle file.
            storeFile file("my-release-key.jks")
            storePassword "password"
            keyAlias "my-alias"
            keyPassword "password"
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
            ...
        }
    }
}

यदि आपने अपनी रिलीज़ कुंजी का नाम डिफ़ॉल्ट के अलावा किसी अन्य चीज़ में बदल दिया है, तो नया नाम निर्दिष्ट करना सुनिश्चित करें। उपनाम के लिए भी यही बात है।

आपका स्टोर पासवर्ड वही पासवर्ड होगा जो आपने पहली बार Play Store पर अपना ऐप अपलोड करते समय जेनरेट किया था।

अब, जब आप ./gradlew :app:bundleRelease . कमांड चलाते हैं Android Studio में कमांड लाइन से, आप देखेंगे कि यह एक हस्ताक्षरित ऐप बंडल जेनरेट करता है।

हस्ताक्षरित जानकारी कैसे साफ़ करें

build.gradle . में सादे पाठ के रूप में उपलब्ध हस्ताक्षर जानकारी के साथ कमिटिंग कोड फ़ाइल एक सुरक्षा जोखिम है और अटैक वेक्टर हो सकता है।

Google के पास इसके आसपास के दस्तावेज़ हैं जो आपको यहां मिल सकते हैं।

सबसे पहले, एक keystore.properties बनाएं अपनी परियोजना निर्देशिका के मूल में फ़ाइल करें।

फ़ाइल की सामग्री नीचे दी गई होनी चाहिए:

storePassword=myStorePassword
keyPassword=myKeyPassword
keyAlias=myKeyAlias
storeFile=myStoreFileLocation

आपका स्टोर पासवर्ड और कुंजी पासवर्ड वह पासवर्ड होगा जिसका उपयोग आपने पहली बार ऐप स्टोर पर अपना ऐप बंडल अपलोड करते समय किया था।

आपका keyAlias और storeFile आपकी निजी कुंजी बनाते समय आपके द्वारा निर्दिष्ट उपनाम और आपके द्वारा बनाई गई निजी कुंजी का स्थान क्रमशः होगा।

अब, हमें इस फ़ाइल को build.gradle . में लोड करना होगा . यह शुरुआत में मेरे लिए एक आश्चर्य के रूप में आया, लेकिन ग्रैडल वास्तव में एक डीएसएल के रूप में काम करता है। इसलिए, ग्रैडल का उपयोग करके कॉन्फ़िगरेशन लिखना आसान बनाता है।

//  Load properties from keystore.properties
def keystorePropertiesFile = rootProject.file("keystore.properties")

//  Creating a new Properties() object
def keystoreProperties = new Properties()

//  If keystorePropertiesFile exists, read from that, else set from build environment
if (keystorePropertiesFile.exists()) {
    //  Loading the keystoreProperties file
    keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
} else {
    //  Read all environment variables from the build environment
    keystoreProperties.setProperty("storeFile", "${System.getenv('STORE_FILE')}")
    keystoreProperties.setProperty("keyAlias", "${System.getenv('KEY_ALIAS')}")
    keystoreProperties.setProperty("keyPassword", "${System.getenv('KEY_PASSWORD')}")
    keystoreProperties.setProperty("storePassword", "${System.getenv('STORE_PASSWORD')}")
}

आप वहां पर if स्थिति देखेंगे - अभी इसके बारे में चिंता न करें। यह विशेष रूप से बाद में कोड बिल्ड के लिए खाता है।

ऐसा करने के बाद, अपना signingConfigs बदलें build.gradle . में अनुभाग इस तरह दिखने के लिए:

signingConfigs {
        release {
            storeFile file(keystoreProperties['storeFile'])
            keyAlias keystoreProperties['keyAlias']
            keyPassword keystoreProperties['keyPassword']
            storePassword keystoreProperties['storePassword']
        }
    }

AWS कोड पाइपलाइन कैसे सेट करें

मैं इस पर बहुत अधिक विस्तार में नहीं जा रहा हूँ क्योंकि यह अपेक्षाकृत सरल है।

निम्नलिखित तीन चरणों के साथ एक AWS कोड पाइपलाइन स्थापित करें:

1. स्रोत चरण आपके GitHub रिपॉजिटरी के master से जुड़ा है शाखा
2. एडब्ल्यूएस कोड बिल्ड से कनेक्टेड स्टेज बनाएं
3. तैनाती चरण जो S3 बकेट में परिनियोजित होगा।

आप यहां कोड पाइपलाइन स्थापित करने के बारे में अधिक दस्तावेज़ीकरण प्राप्त कर सकते हैं।

AWS S3 कैसे सेट करें

सबसे पहले, सुनिश्चित करें कि आपके पास एक चरण के रूप में कोड बिल्ड के साथ एक कोड पाइपलाइन स्थापित है। इसके बाद, दो S3 बकेट सेट करें:

1. आपकी रिलीज कुंजी को स्टोर करने के लिए एक बकेट। मैं इस बकेट को कॉल कर रहा हूं release-key.jks
2. एक बकेट जिसमें आप अपना Google Play सेवा खाता निजी कुंजी संग्रहीत करेंगे। (आपको अपना सेवा खाता बनाते समय यह कुंजी डाउनलोड करनी चाहिए थी।)

आपको अपनी कोड बिल्ड सेवा भूमिका से इन बकेट तक पहुंच की अनुमति देनी होगी। जब आप अपना कोड पाइपलाइन सेट करते हैं तो आपकी कोड बिल्ड सेवा भूमिका बनाई जानी चाहिए थी।

IAM कंसोल पर जाएं और अपनी कोड बिल्ड सेवा भूमिका ढूंढें और ARN प्राप्त करें।

इसके बाद, बकेट के लिए अनुमतियाँ टैब पर जाने के लिए कंसोल का उपयोग करें release-key.jks और वहां निम्न नीति जोड़ें:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "AWS": [
                    "arn:aws:iam::123456789:role/service-role/codebuild-service-role-dummy",
                ]
            },
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::release-key-bucket/*"
        }
    ]
}

यह नीति उस मशीन से S3 बकेट तक पहुंच की अनुमति देगी जहां आपका कोडबिल्ड प्रोजेक्ट निष्पादित होगा।

आपको ऊपर बताए गए एआरएन को अपने खाते के एआरएन से बदलना होगा। जब आप नीति अपडेट कर रहे हों, तो कोड बिल्ड सेवा भूमिका के लिए सही ARN निर्दिष्ट करना सुनिश्चित करें।

आपको दूसरी बकेट के लिए अनुमति नीति को बदलने की आवश्यकता नहीं है। हम एडब्ल्यूएस लैम्ब्डा भूमिका के लिए प्रासंगिक अनुमतियां जोड़ देंगे ताकि इसे बकेट तक पहुंचने की अनुमति मिल सके।

AWS कोडबिल्ड कैसे सेट करें

इसके बाद, एक buildspec.yml बनाएं अपने प्रोजेक्ट रूट फ़ोल्डर में फ़ाइल करें।

version: 0.2

phases:
  build:
    commands:
      - aws s3api get-object --bucket release-key.jks --key release-key.jks ./releaseKey.jks
      - cp ./releaseKey.jks ${CODEBUILD_SRC_DIR}/app/releaseKey.jks
      - export STORE_FILE=releaseKey.jks
      - export KEY_ALIAS=$keyAlias
      - export KEY_PASSWORD=$keyPassword
      - export STORE_PASSWORD=$storePassword
      - ./gradlew :app:bundleRelease

artifacts:
  files:
    - app/build/outputs/bundle/release/app-release.aab

यह फ़ाइल काफी सरल है। यह निर्दिष्ट बकेट से रिलीज कुंजी प्राप्त करता है और इसे कोड बिल्ड सर्वर पर एक स्थानीय फ़ाइल में निर्दिष्ट स्थान पर सहेजता है।

इसके बाद, build.gradle . के लिए आवश्यक सभी चर निर्यात करें कॉन्फ़िगरेशन सही ढंग से काम करने के लिए। अंत में, कमांड लाइन से ग्रैडल की रिलीज़ कमांड चलाएँ।

इससे पहले कि आप इस स्क्रिप्ट को कोड बिल्ड में चला सकें, आपको कोड बिल्ड वातावरण में वेरिएबल्स को जोड़ना होगा। ऐसा करने के लिए, पहले एडब्ल्यूएस कोड बिल्ड कंसोल पर जाएं और अपने एंड्रॉइड ऐप के लिए अपना बिल्ड प्रोजेक्ट चुनें।

इसके बाद, नीचे दिए गए स्क्रीनशॉट में संपादित करें> पर्यावरण जैसा माहौल चुनें:

ऐसा करने के बाद स्क्रीन पर जो पॉप अप होता है, अतिरिक्त कॉन्फ़िगरेशन ड्रॉपडाउन का चयन करें। वहां आपको मुख्य मान जोड़े के माध्यम से पर्यावरण चर जोड़ने का विकल्प दिखाई देगा।

अब जब कोड बिल्ड buildspec.yml चलाता है फ़ाइल, यह निर्दिष्ट चर निर्यात करने में सक्षम होगा।

जैसे ही चीजें अभी खड़ी हैं, जब आपकी पाइपलाइन चलती है, कोड बिल्ड आपके एंड्रॉइड ऐप पर हस्ताक्षर करने और बनाने के लिए निजी कुंजी डाउनलोड करने में सक्षम होगा और हस्ताक्षरित बंडल को S3 बाल्टी में अपलोड करेगा।

स्लैक ऐप कैसे सेट करें

ऑब्जर्वेबिलिटी ऑटोमेशन की पहचान है। आप जानना चाहते हैं कि आपका ऑटोमेशन कब चलता है, यह सफल होता है या विफल, और यदि यह विफल हो जाता है, तो विफलता का कारण।

क्लाउडवॉच के माध्यम से एडब्ल्यूएस आम तौर पर अवलोकन क्षमता को संभालता है। लेकिन मुझे लगता है कि एक स्लैक एकीकरण उद्देश्य को भी पूरा करता है।

स्लैक को अपने ऑटोमेशन वर्कफ़्लोज़ में एकीकृत करने का सबसे आसान तरीका है कि आप एक स्लैक ऐप सेट करें और अपने ऑटोमेशन वर्कफ़्लो से उस ऐप को एक नोटिफिकेशन भेजें।

स्लैक ऐप कैसे सेट करें, यह जानने के लिए, यहां दस्तावेज़ देखें। प्रक्रिया बहुत आसान है और आपके पास कुछ ही मिनटों में एक ऐप तैयार हो जाना चाहिए।

एक बार जब आप ऐप बना लेते हैं, तो आपको एक वेबहुक यूआरएल मिलेगा जिसका उपयोग आप संबंधित चैनल में पोस्ट करने के लिए ऐप को कॉल करने के लिए कर सकते हैं। इस WebHook URL पर नज़र रखें क्योंकि हम इसका उपयोग AWS लैम्ब्डा फ़ंक्शन के साथ करेंगे।

AWS लैम्ब्डा कैसे सेट करें

अब तक, हमारे पास एक S3 बकेट में हस्ताक्षरित, निर्मित और अपलोड किया जा रहा एक Android ऐप बंडल है। इसके बाद, हमें यह पता लगाना होगा कि प्ले स्टोर पर बंडल को बीटा ट्रैक पर कैसे अपलोड किया जाए।

ऐसा करने का तरीका एक एडब्ल्यूएस लैम्ब्डा स्थापित करना है जो तब शुरू हो जाएगा जब बंडल को एस 3 बाल्टी में अपलोड किया जाएगा। जब यह ट्रिगर होता है, तो लैम्ब्डा चलेगा, बंडल डाउनलोड करेगा, सेवा खाता कुंजी पकड़ेगा, और बंडल को Play Store बीटा ट्रैक पर अपलोड करेगा।

एक बार जब आप लैम्ब्डा बना लेते हैं और बकेट में फ़ाइल अपलोड होने पर इसे चलाने के लिए ट्रिगर जोड़ते हैं, तो नीचे दिए गए कोड को देखें:

"""This Python3 script is used to upload a new .aab bundle to the play store. The execution of this Python script
    occurs through an AWS Lambda which is invoked when a new file is uploaded to the relevant S3 buckets"""

import json
import boto3
import os
from urllib import request, parse
from google.oauth2 import service_account
import googleapiclient.discovery

#   Defining the scope of the authorization request
SCOPES = ['https://www.googleapis.com/auth/androidpublisher']

#   Package name for app
package_name = 'com.app.name'

#   Define the slack webhook url
slack_webhook_url = os.environ['SLACK_WEBHOOK_URL']

def send_slack_message(message):
    data = json.dumps({ 'text': message })
    post_data = data.encode('utf-8')
    req = request.Request(slack_webhook_url, data=post_data, headers={ 'Content-Type': 'application/json' })
    request.urlopen(req)

#   This is the main handler function
def lambda_handler(event, context):
    #   Create a new client S3 client and download the correct file from the bucket
    s3 = boto3.client('s3')
    s3.download_file('service-account-bucket-key', 'service-account-bucket-key.json', '/tmp/service-account-key.json')
    SERVICE_ACCOUNT_FILE = '/tmp/service-account-key.json'

    #   Download the app-release.aab file that triggered the Lambda
    bucket_name = event['Records'][0]['s3']['bucket']['name']
    file_key = event['Records'][0]['s3']['object']['key']
    s3.download_file(bucket_name, file_key, '/tmp/app-release.aab')
    APP_BUNDLE = '/tmp/app-release.aab'

    print(f"A bundle uploaded to {bucket_name} has triggered the Lambda")

    #   Create a credentials object and create a service object using the credentials object
    credentials = service_account.Credentials.from_service_account_file(
        SERVICE_ACCOUNT_FILE, scopes=SCOPES
    )
    service = googleapiclient.discovery.build('androidpublisher', 'v3', credentials=credentials, cache_discovery=False)
    
    #   Create an edit request using the service object and get the editId
    edit_request = service.edits().insert(body={}, packageName=package_name)
    result = edit_request.execute()
    edit_id = result['id']

    #   Create a request to upload the app bundle
    try:
        bundle_response = service.edits().bundles().upload(
            editId=edit_id,
            packageName=package_name,
            media_body=APP_BUNDLE,
            media_mime_type="application/octet-stream"
        ).execute()
    except Exception as err:
        message = f"There was an error while uploading a new version of {package_name}"
        send_slack_message(message)
        raise err

    print(f"Version code {bundle_response['versionCode']} has been uploaded")

    #   Create a track request to upload the bundle to the beta track
    track_response = service.edits().tracks().update(
        editId=edit_id,
        track='beta',
        packageName=package_name,
        body={u'releases': [{
            u'versionCodes': [str(bundle_response['versionCode'])],
            u'status': u'completed',
        }]}
    ).execute()

    print("The bundle has been committed to the beta track")

    #   Create a commit request to commit the edit to BETA track
    commit_request = service.edits().commit(
        editId=edit_id,
        packageName=package_name
    ).execute()

    print(f"Edit {commit_request['id']} has been committed")

    message = f"Version code {bundle_response['versionCode']} has been uploaded from the bucket {bucket_name}.\nEdit {commit_request['id']} has been committed"
    send_slack_message(message)
    
    return {
        'statusCode': 200,
        'body': json.dumps('Successfully executed the app bundle release to beta')
    }

ऊपर दिया गया लैम्ब्डा googleapiclient . का उपयोग करेगा Google Play के प्रकाशन API के लिए URL बनाने के लिए लाइब्रेरी और उसका डिस्कवरी मॉड्यूल।

इसके बाद, लैम्ब्डा आपके द्वारा पहले सेट की गई बकेट से सेवा खाता कुंजी डाउनलोड करेगा। आपको यह सुनिश्चित करना होगा कि आपने सही बकेट नाम निर्दिष्ट किए हैं।

अपलोड सफल होता है या विफल, इस पर निर्भर करते हुए, हम चाहते हैं कि एक स्लैक संदेश बाहर जाए। लैम्ब्डा के लिए पर्यावरण चर में पिछले अनुभाग से स्लैक वेबहुक यूआरएल जोड़ें। उपरोक्त फ़ंक्शन पायथन के os का उपयोग करता है पर्यावरण चर तक पहुंच प्राप्त करने के लिए मॉड्यूल और संदेश को स्लैक पर पोस्ट करें।

यदि आपका लैम्ब्डा विफल हो जाता है, तो ऐसा इसलिए हो सकता है क्योंकि आपके लैम्ब्डा के पास S3 बकेट तक पहुँचने की अनुमति नहीं है जहाँ आपके Google Play सेवा खाते की कुंजी संग्रहीत है। उस स्थिति में, आपको यह इंगित करने वाला एक त्रुटि संदेश दिखाई देगा।

इसे ठीक करने के लिए, आपको बस अपनी लैम्ब्डा भूमिका में प्रासंगिक अनुमतियाँ जोड़नी होंगी।

यहां वह नीति है जिसे आपको जोड़ना होगा:

{
    "Version": "2012-10-07",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObjectVersion",
                "s3:GetBucketVersioning",
                "s3:GetBucketAcl",
                "s3:GetObject",
                "s3:GetBucketTagging",
                "s3:GetBucketLocation",
                "s3:GetObjectVersionAcl"
            ],
            "Resource": [
                "arn:aws:s3:::arn:aws:s3:::your-bucket-name-with-service-account-key"
            ]
        }
    ]
}

बाल्टी के लिए एआरएन को अपने खाते के लिए प्रासंगिक बकेट से बदलें और आपको जाने के लिए अच्छा होना चाहिए।

निष्कर्ष

इसलिए यह अब आपके पास है। यह निश्चित रूप से आसान नहीं था और इसमें बहुत सारे चलने वाले हिस्से हैं, लेकिन यह एक स्वचालन है जो आपको बहुत समय और प्रयास बचाएगा।

यदि आप एक ऐसी टीम का हिस्सा हैं जो बार-बार नए ऐप अपडेट जारी कर रही है, तो आप एक ऐसे व्यक्ति की अनुपस्थिति में बाधा नहीं बनना चाहते हैं जिसका काम अपडेट जारी करना है।

इस तरह के ऑटोमेशन का निर्माण आपके CI/CD वर्कफ़्लो को बहुत आसान और अधिक मज़बूत बनाता है।

यदि आप इस तरह के ब्लॉग में रुचि रखते हैं, तो आप https://redixhumayun.github.io पर अधिक पढ़ सकते हैं या ट्विटर पर मुझे फ़ॉलो कर सकते हैं।