આ લેખમાં, હું ગ્રેડલ બિલ્ડરનો ઉપયોગ કરીને સોનાટાઇપ મેવેન સેન્ટ્રલ રિપોઝીટરીમાં ગીથબ એક્શન દ્વારા શરૂઆતથી જાવા આર્ટિફેક્ટ પ્રકાશિત કરવાની પ્રક્રિયાને નજીકથી જોવા માંગુ છું.

એક જગ્યાએ સામાન્ય ટ્યુટોરીયલ ન હોવાને કારણે મેં આ લેખ લખવાનું નક્કી કર્યું. તમામ માહિતી વિવિધ સ્ત્રોતોમાંથી ટુકડે-ટુકડે એકત્રિત કરવાની હતી, વધુમાં, સંપૂર્ણપણે તાજી નથી. કોણ કાળજી લે છે, બિલાડી હેઠળ સ્વાગત છે.

Sonatype માં ભંડાર બનાવવું

પ્રથમ પગલું એ સોનાટાઇપ મેવેન સેન્ટ્રલમાં રીપોઝીટરી બનાવવાનું છે. આ માટે અમે જઈએ છીએ અહીં, નોંધણી કરો અને નવું કાર્ય બનાવો, અમને રીપોઝીટરી બનાવવા માટે પૂછો. અમે અમારા માં વાહન ગ્રુપ આઈડી પ્રોજેક્ટ, પ્રોજેક્ટ URL પ્રોજેક્ટ લિંક અને SCM url વર્ઝન કંટ્રોલ સિસ્ટમની લિંક જેમાં પ્રોજેક્ટ સ્થિત છે. ગ્રુપ આઈડી અહીં ફોર્મનું હોવું જોઈએ com.example, com.example.domain, com.example.testsupport, અને તે તમારા ગીથબની લિંકના સ્વરૂપમાં પણ હોઈ શકે છે: github.com/yourusername -> io.github.yourusername. કોઈપણ કિસ્સામાં, તમારે આ ડોમેન અથવા પ્રોફાઇલની માલિકી ચકાસવાની જરૂર પડશે. જો તમે ગીથબ પ્રોફાઇલનો ઉલ્લેખ કર્યો છે, તો તમને ઇચ્છિત નામ સાથે સાર્વજનિક રિપોઝીટરી બનાવવા માટે કહેવામાં આવશે.

કન્ફર્મેશન પછી અમુક સમય પછી, તમારી ગ્રુપઆઈડી બનાવવામાં આવશે અને અમે આગળના પગલા, ગ્રેડલ કન્ફિગરેશન પર આગળ વધી શકીએ છીએ.

Gradle રૂપરેખાંકિત કરી રહ્યા છીએ

લેખન સમયે, મને ગ્રેડલ પ્લગિન્સ મળ્યાં નથી જે આર્ટિફેક્ટ પ્રકાશિત કરવામાં મદદ કરી શકે. આ એકમાત્ર પ્લગઇન જે મને મળ્યું, જો કે, લેખકે તેને વધુ સમર્થન આપવાનો ઇનકાર કર્યો. તેથી, મેં બધું જાતે કરવાનું નક્કી કર્યું, કારણ કે આ કરવું ખૂબ મુશ્કેલ નથી.

પ્રકાશન માટે સોનાટાઇપની જરૂરિયાતો શોધવા માટેની પ્રથમ વસ્તુ છે. તેઓ નીચે મુજબ છે.

• સ્ત્રોત કોડ્સ અને JavaDocની ઉપલબ્ધતા, એટલે કે. હાજરી આપવી જોઈએ -sources.jar и-javadoc.jar ફાઈલો. દસ્તાવેજીકરણમાં જણાવ્યા મુજબ, જો સ્રોત કોડ અથવા દસ્તાવેજીકરણ પ્રદાન કરવું શક્ય ન હોય, તો તમે ડમી બનાવી શકો છો -sources.jar અથવા -javadoc.jar ટેસ્ટ પાસ કરવા માટે અંદર એક સરળ README સાથે.
• બધી ફાઇલો સાથે સહી કરવી આવશ્યક છે GPG/PGPઅને .asc દરેક ફાઇલ માટે સહી ધરાવતી ફાઇલનો સમાવેશ થવો આવશ્યક છે.
• પ્રાપ્યતા pom ફાઇલ
• યોગ્ય મૂલ્યો groupId, artifactId и version. સંસ્કરણ એક મનસ્વી સ્ટ્રિંગ હોઈ શકે છે અને તેની સાથે સમાપ્ત થઈ શકતું નથી -SNAPSHOT
• હાજરી જરૂરી name, description и url
• લાઇસન્સ, વિકાસકર્તાઓ અને સંસ્કરણ નિયંત્રણ સિસ્ટમ વિશેની માહિતીની હાજરી

આ મૂળભૂત નિયમો છે જે પ્રકાશિત કરતી વખતે અનુસરવા આવશ્યક છે. સંપૂર્ણ માહિતી ઉપલબ્ધ અહીં.

અમે આ આવશ્યકતાઓને અમલમાં મૂકીએ છીએ build.gradle ફાઇલ પ્રથમ, ચાલો વિકાસકર્તાઓ, લાઇસન્સ, સંસ્કરણ નિયંત્રણ સિસ્ટમ વિશેની બધી જરૂરી માહિતી ઉમેરીએ અને પ્રોજેક્ટનું url, નામ અને વર્ણન પણ સેટ કરીએ. ચાલો આ માટે એક સરળ પદ્ધતિ લખીએ:

def customizePom(pom) {
    pom.withXml {
        def root = asNode()

        root.dependencies.removeAll { dep ->
            dep.scope == "test"
        }

        root.children().last() + {
            resolveStrategy = DELEGATE_FIRST

            description 'Some description of artifact'
            name 'Artifct name'
            url 'https://github.com/login/projectname'
            organization {
                name 'com.github.login'
                url 'https://github.com/login'
            }
            issueManagement {
                system 'GitHub'
                url 'https://github.com/login/projectname/issues'
            }
            licenses {
                license {
                    name 'The Apache License, Version 2.0'
                    url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                }
            }
            scm {
                url 'https://github.com/login/projectname'
                connection 'scm:https://github.com/login/projectname.git'
                developerConnection 'scm:git://github.com/login/projectname.git'
            }
            developers {
                developer {
                    id 'dev'
                    name 'DevName'
                    email '[email protected]'
                }
            }
        }
    }
}

આગળ, તમારે નિર્દિષ્ટ એસેમ્બલી દરમિયાન તે નિર્દિષ્ટ કરવાની જરૂર છે -sources.jar и-javadoc.jar ફાઈલો. આ વિભાગ માટે java તમારે નીચેના ઉમેરવાની જરૂર છે:

java {
    withJavadocJar()
    withSourcesJar()
}

ચાલો છેલ્લી જરૂરિયાત તરફ આગળ વધીએ, GPG/PGP હસ્તાક્ષર ગોઠવીએ. આ કરવા માટે, પ્લગઇનને કનેક્ટ કરો signing:

plugins {
    id 'signing'
}

અને એક વિભાગ ઉમેરો:

signing {
    sign publishing.publications
}

છેલ્લે, ચાલો એક વિભાગ ઉમેરીએ publishing:

publishing {
    publications {
        mavenJava(MavenPublication) {
            customizePom(pom)
            groupId group
            artifactId archivesBaseName
            version version

            from components.java
        }
    }
    repositories {
        maven {
            url "https://oss.sonatype.org/service/local/staging/deploy/maven2"
            credentials {
                username sonatypeUsername
                password sonatypePassword
            }
        }
    }
}

તે sonatypeવપરાશકર્તા નામ и sonatypeપાસવર્ડ પર નોંધણી દરમિયાન બનાવેલ લોગિન અને પાસવર્ડ ધરાવતા ચલ sonatype.org.

આમ ફાઈનલ build.gradle આના જેવો દેખાશે:

સંપૂર્ણ બિલ્ડ.ગ્રેડલ કોડ

plugins {
    id 'java'
    id 'maven-publish'
    id 'signing'
}

java {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
    withJavadocJar()
    withSourcesJar()
}

group 'io.github.githublogin'
archivesBaseName = 'projectname'
version = System.getenv('RELEASE_VERSION') ?: "0.0.1"

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.2'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.5.2'
}

test {
    useJUnitPlatform()
}

jar {
    from sourceSets.main.output
    from sourceSets.main.allJava
}

signing {
    sign publishing.publications
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            customizePom(pom)
            groupId group
            artifactId archivesBaseName
            version version

            from components.java
        }
    }
    repositories {
        maven {
            url "https://oss.sonatype.org/service/local/staging/deploy/maven2"
            credentials {
                username sonatypeUsername
                password sonatypePassword
            }
        }
    }
}

def customizePom(pom) {
    pom.withXml {
        def root = asNode()

        root.dependencies.removeAll { dep ->
            dep.scope == "test"
        }

        root.children().last() + {
            resolveStrategy = DELEGATE_FIRST

            description 'Some description of artifact'
            name 'Artifct name'
            url 'https://github.com/login/projectname'
            organization {
                name 'com.github.login'
                url 'https://github.com/githublogin'
            }
            issueManagement {
                system 'GitHub'
                url 'https://github.com/githublogin/projectname/issues'
            }
            licenses {
                license {
                    name 'The Apache License, Version 2.0'
                    url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                }
            }
            scm {
                url 'https://github.com/githublogin/projectname'
                connection 'scm:https://github.com/githublogin/projectname.git'
                developerConnection 'scm:git://github.com/githublogin/projectname.git'
            }
            developers {
                developer {
                    id 'dev'
                    name 'DevName'
                    email '[email protected]'
                }
            }
        }
    }
}

હું નોંધવા માંગુ છું કે અમને પર્યાવરણ વેરીએબલમાંથી સંસ્કરણ મળે છે: System.getenv('RELEASE_VERSION'). અમે તેને એસેમ્બલી દરમિયાન ઉજાગર કરીશું અને તેને ટેગ નામમાંથી લઈશું.

પીજીપી કી જનરેશન

Sonatype ની આવશ્યકતાઓમાંની એક એ છે કે બધી ફાઇલો GPG/PGP કી વડે સહી કરવી. આ માટે અમે જઈએ છીએ અહીં અને તમારી ઓપરેટિંગ સિસ્ટમ માટે GnuPG ઉપયોગિતા ડાઉનલોડ કરો.

• અમે કી જોડી બનાવીએ છીએ: gpg --gen-key, વપરાશકર્તા નામ, ઈ-મેલ દાખલ કરો અને પાસવર્ડ પણ સેટ કરો.
• શોધી કાઢવું id આદેશ સાથે અમારી કી: gpg --list-secret-keys --keyid-format short. આઈડી સ્લેશ પછી નિર્દિષ્ટ કરવામાં આવશે, ઉદાહરણ તરીકે: rsa2048/9B695056
• સર્વર પર જાહેર કી પ્રકાશિત કરી રહ્યા છીએ https://keys.openpgp.org આદેશ: gpg --keyserver [https://keys.openpgp.org](https://keys.openpgp.org/) --send-keys 9B695056
• અમે ગુપ્ત કીને મનસ્વી સ્થળે નિકાસ કરીએ છીએ, અમને ભવિષ્યમાં તેની જરૂર પડશે: gpg --export-secret-key 9B695056 > D:\gpg\9B695056.gpg

Github ક્રિયાઓ સુયોજિત કરી રહ્યા છીએ

ચાલો અંતિમ તબક્કામાં આગળ વધીએ, બિલ્ડ સેટ કરો અને ગીથબ ક્રિયાઓનો ઉપયોગ કરીને સ્વતઃ-પ્રકાશિત કરીએ.
ગીથબ એક્શન્સ એ એક વિશેષતા છે જે તમને સંપૂર્ણ CI/CD ચક્ર અમલમાં મૂકીને વર્કફ્લોને સ્વચાલિત કરવાની મંજૂરી આપે છે. બિલ્ડ, ટેસ્ટ અને ડિપ્લોય વિવિધ ઇવેન્ટ્સ દ્વારા ટ્રિગર થઈ શકે છે: કોડ પુશ, રિલીઝ બનાવટ અથવા સમસ્યાઓ. આ કાર્યક્ષમતા જાહેર ભંડારો માટે સંપૂર્ણપણે મફત છે.

આ વિભાગમાં, હું તમને બતાવીશ કે બિલ્ડ અને પુશ કોડ કેવી રીતે સેટ કરવો અને રિલીઝ પર સોનાટાઇપ રિપોઝીટરીમાં કેવી રીતે જમાવવું, તેમજ રહસ્યો કેવી રીતે સેટ કરવી.

અમે રહસ્યો સેટ કરીએ છીએ

સ્વયંસંચાલિત એસેમ્બલી અને જમાવટ માટે, અમને સંખ્યાબંધ ગુપ્ત મૂલ્યોની જરૂર હોય છે, જેમ કે કી id, કી જનરેટ કરતી વખતે અમે દાખલ કરેલ પાસવર્ડ, PGP કી પોતે અને Sonatype લોગિન/પાસવર્ડ. તમે તેમને રિપોઝીટરી સેટિંગ્સમાં વિશિષ્ટ વિભાગમાં સેટ કરી શકો છો:

અમે નીચેના ચલો સેટ કરીએ છીએ:

• SONATYPE_USERNAME / SONATYPE_PASSWORD - લોગિન / પાસવર્ડ જે અમે Sonatype સાથે નોંધણી કરતી વખતે દાખલ કર્યો હતો
• SIGNING_KEYID/SIGNING_PASSWORD — જનરેશન દરમિયાન PGP કી આઈડી અને પાસવર્ડ સેટ.

હું વધુ વિગતમાં GPG_KEY_CONTENTS ચલ પર રહેવા માંગુ છું. હકીકત એ છે કે પ્રકાશન માટે અમને ખાનગી PGP કીની જરૂર છે. તેને રહસ્યોમાં પોસ્ટ કરવા માટે, મેં તેનો ઉપયોગ કર્યો સૂચના અને વધુમાં સંખ્યાબંધ ક્રિયાઓ કરી.

• ચાલો આપણી કીને gpg વડે એન્ક્રિપ્ટ કરીએ: gpg --symmetric --cipher-algo AES256 9B695056.gpgપાસવર્ડ દાખલ કરીને. તે ચલમાં મૂકવું જોઈએ: SECRET_PASSPHRASE
• ચાલો બેઝ 64 નો ઉપયોગ કરીને પ્રાપ્ત થયેલ એન્ક્રિપ્ટેડ કીને ટેક્સ્ટ ફોર્મમાં અનુવાદિત કરીએ: base64 9B695056.gpg.gpg > 9B695056.txt. સામગ્રીને ચલમાં મૂકવામાં આવશે: GPG_KEY_CONTENTS.

કોડને દબાણ કરતી વખતે અને PR બનાવતી વખતે સેટઅપ બનાવો

પ્રથમ તમારે તમારા પ્રોજેક્ટના રૂટમાં એક ફોલ્ડર બનાવવાની જરૂર છે: .github/workflows.

તેમાં, ફાઇલને માર્ક અપ કરો, ઉદાહરણ તરીકે, gradle-ci-build.yml નીચેની સામગ્રી સાથે:

name: build

on:
  push:
    branches:
      - master
      - dev
      - testing
  pull_request:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v1
      - name: Set up JDK 8
        uses: actions/setup-java@v1
        with:
          java-version: 8

      - name: Build with Gradle
        uses: eskatos/gradle-command-action@v1
        with:
          gradle-version: current
          arguments: build -PsonatypeUsername=${{secrets.SONATYPE_USERNAME}} -PsonatypePassword=${{secrets.SONATYPE_PASSWORD}}

શાખાઓ પર દબાણ કરતી વખતે આ વર્કફ્લો ચલાવવામાં આવશે master, dev и testingપુલ વિનંતીઓ બનાવતી વખતે પણ.

જોબ્સ વિભાગ ઉલ્લેખિત ઇવેન્ટ્સ પર અમલમાં મૂકવાના પગલાંનો ઉલ્લેખ કરે છે. આ કિસ્સામાં, અમે ઉબુન્ટુના નવીનતમ સંસ્કરણ પર નિર્માણ કરીશું, જાવા 8 નો ઉપયોગ કરીશું અને ગ્રેડલ માટે પ્લગઇનનો ઉપયોગ કરીશું. eskatos/gradle-command-action@v1જે, બિલ્ડરના નવીનતમ સંસ્કરણનો ઉપયોગ કરીને, તેમાં ઉલ્લેખિત આદેશો ચલાવશે arguments. ચલો secrets.SONATYPE_USERNAME и secrets.SONATYPE_PASSWORD આ તે રહસ્યો છે જે અમે અગાઉ પૂછ્યા હતા.

બિલ્ડ પરિણામો ક્રિયાઓ ટેબમાં પ્રતિબિંબિત થશે:

જ્યારે નવી રીલીઝ થાય ત્યારે સ્વતઃ જમાવટ કરો

ચાલો autodeploy માટે એક અલગ વર્કફ્લો ફાઈલ બનાવીએ gradle-ci-publish.yml:

name: publish

on:
  push:
    tags:
      - 'v*'

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v1
      - name: Set up JDK 8
        uses: actions/setup-java@v1
        with:
          java-version: 8

      - name: Prepare to publish
        run: |
          echo '${{secrets.GPG_KEY_CONTENTS}}' | base64 -d > publish_key.gpg
          gpg --quiet --batch --yes --decrypt --passphrase="${{secrets.SECRET_PASSPHRASE}}" 
          --output secret.gpg publish_key.gpg
          echo "::set-env name=RELEASE_VERSION::${GITHUB_REF:11}"

      - name: Publish with Gradle
        uses: eskatos/gradle-command-action@v1
        with:
          gradle-version: current
          arguments: test publish -Psigning.secretKeyRingFile=secret.gpg -Psigning.keyId=${{secrets.SIGNING_KEYID}} -Psigning.password=${{secrets.SIGNING_PASSWORD}} -PsonatypeUsername=${{secrets.SONATYPE_USERNAME}} -PsonatypePassword=${{secrets.SONATYPE_PASSWORD}}

ફાઇલ લગભગ પાછલી ફાઇલ જેવી જ છે, સિવાય કે તે ઇવેન્ટ કે જેમાં તે ટ્રિગર થશે. આ કિસ્સામાં, v થી શરૂ થતા નામ સાથે ટેગ બનાવવાની આ ઘટના છે.

જમાવટ પહેલાં, અમારે રહસ્યોમાંથી PGP કી કાઢવાની અને તેને પ્રોજેક્ટના રૂટમાં મૂકવાની સાથે સાથે તેને ડિક્રિપ્ટ કરવાની જરૂર છે. આગળ, આપણે વિશિષ્ટ પર્યાવરણ ચલ સેટ કરવાની જરૂર છે RELEASE_VERSION જેનો આપણે ઉલ્લેખ કરીએ છીએ gradle.build ફાઇલ આ બધું વિભાગમાં કરવામાં આવે છે Prepare to publish. અમે GPG_KEY_CONTENTS વેરીએબલમાંથી અમારી કી મેળવીએ છીએ, તેને gpg ફાઇલમાં અનુવાદિત કરીએ છીએ, પછી તેને ફાઇલમાં મૂકીને તેને ડિક્રિપ્ટ કરીએ છીએ. secret.gpg.

આગળ, આપણે વિશિષ્ટ ચલ તરફ વળીએ છીએ GITHUB_REF, જેમાંથી આપણે ટેગ બનાવતી વખતે સેટ કરેલ વર્ઝન મેળવી શકીએ છીએ. આ ચલ આ કિસ્સામાં સંબંધિત છે. refs/tags/v0.0.2 જેમાંથી અમે ચોક્કસ સંસ્કરણ મેળવવા માટે પ્રથમ 11 અક્ષરોને કાપી નાખ્યા. આગળ, અમે પ્રકાશન માટે પ્રમાણભૂત Gradle આદેશોનો ઉપયોગ કરીએ છીએ: test publish

સોનાટાઇપ રીપોઝીટરીમાં જમાવટના પરિણામો તપાસી રહ્યા છીએ

એકવાર રિલીઝ થઈ જાય, પછી અગાઉના વિભાગમાં વર્ણવેલ વર્કફ્લો શરૂ થવો જોઈએ. આ કરવા માટે, એક પ્રકાશન બનાવો:

ટેગ નામ v થી શરૂ થવું જોઈએ. જો, પ્રકાશન પ્રકાશિત કરો પર ક્લિક કર્યા પછી, વર્કફ્લો સફળતાપૂર્વક પૂર્ણ થાય છે, તો અમે જઈ શકીએ છીએ સોનાટાઇપ નેક્સસ ખાતરી કરવા માટે:

આ આર્ટિફેક્ટ સ્ટેજિંગ રિપોઝીટરીમાં દેખાય છે. તે તરત જ ઓપન સ્ટેટસમાં દેખાય છે, પછી તેને યોગ્ય બટન દબાવીને મેન્યુઅલી ક્લોઝ સ્ટેટસમાં ટ્રાન્સફર કરવું આવશ્યક છે. બધી આવશ્યકતાઓ પૂરી થઈ છે કે કેમ તે તપાસ્યા પછી, આર્ટિફેક્ટ બંધ સ્થિતિમાં જાય છે અને તે હવે ફેરફાર માટે ઉપલબ્ધ નથી. આ સ્વરૂપમાં, તે MavenCentral માં સમાપ્ત થશે. જો બધું બરાબર છે, તો તમે બટન દબાવી શકો છો પ્રકાશન, અને આર્ટિફેક્ટ સોનાટાઇપ રીપોઝીટરીમાં સમાપ્ત થશે.

મેવનસેન્ટ્રલમાં આર્ટિફેક્ટ મેળવવા માટે, તમારે તે કાર્યમાં પૂછવાની જરૂર છે જે અમે ખૂબ શરૂઆતમાં બનાવેલ છે. તમારે આ માત્ર એક જ વાર કરવાની જરૂર છે, તેથી અમે પ્રથમ વખત પ્રકાશિત કરીએ છીએ. પછીના સમયમાં, આ જરૂરી નથી, બધું આપમેળે સિંક્રનાઇઝ થશે. તેઓએ મારા માટે ઝડપથી સિંક્રનાઇઝેશન ચાલુ કર્યું, પરંતુ આર્ટિફેક્ટને MavenCentral માં ઉપલબ્ધ થવામાં લગભગ 5 દિવસ લાગ્યા.

આટલું જ, અમે મેવનસેન્ટ્રલમાં અમારી આર્ટિફેક્ટ પ્રકાશિત કરી છે.

ઉપયોગી લિંક્સ

• સમાન લેખ, માત્ર maven મારફતે પ્રકાશિત
• સ્ટેજીંગ ભંડાર સોનાટાઇપ
• Jira સોનાટાઇપ જેમાં ટાસ્ક બનાવવાનું છે
• ઉદાહરણ: રીપોઝીટરી જ્યાં તે બધું સુયોજિત છે

સોર્સ: www.habr.com