ამ სტატიაში მინდა დეტალურად შევხედო Java არტეფაქტის გამოქვეყნების პროცესს ნულიდან Github მოქმედებების მეშვეობით Sonatype Maven ცენტრალურ საცავში Gradle builder-ის გამოყენებით.

ამ სტატიის დაწერა გადავწყვიტე ერთ ადგილას ნორმალური გაკვეთილის არარსებობის გამო. ყველა ინფორმაცია ცალ-ცალკე უნდა შეგროვებულიყო სხვადასხვა წყაროდან, უფრო მეტიც, არც თუ ისე ახალი. ვისაც აინტერესებს, კეთილი იყოს თქვენი მობრძანება კატის ქვეშ.

საცავის შექმნა Sonatype-ში

პირველი ნაბიჯი არის საცავის შექმნა Sonatype Maven Central-ში. ამისთვის მივდივართ აქ, დარეგისტრირდით და შექმენით ახალი დავალება, გვთხოვეთ შევქმნათ საცავი. ჩვენ ვატარებთ ჩვენს GroupId პროექტი, პროექტის URL პროექტის ლინკი და SCM url ვერსიის კონტროლის სისტემის ბმული, რომელშიც მდებარეობს პროექტი. GroupId აქ უნდა იყოს com.example, com.example.domain, com.example.testsupport და ასევე შეიძლება იყოს თქვენი github-ის ბმულის სახით: github.com/თქვენი მომხმარებლის სახელი -> io.github.თქვენი მომხმარებლის სახელი. ნებისმიერ შემთხვევაში, თქვენ უნდა დაადასტუროთ ამ დომენის ან პროფილის საკუთრება. თუ თქვენ მიუთითეთ github პროფილი, მოგეთხოვებათ შექმნათ საჯარო საცავი სასურველი სახელით.

დადასტურებიდან გარკვეული დროის შემდეგ, თქვენი GroupId შეიქმნება და ჩვენ შეგვიძლია გადავიდეთ შემდეგ ეტაპზე, Gradle-ის კონფიგურაციაზე.

Gradle-ის კონფიგურაცია

წერის დროს მე ვერ ვიპოვე Gradle დანამატები, რომლებიც დახმარებოდნენ არტეფაქტის გამოქვეყნებას. იგი ერთადერთი მოდული, რომელიც მე ვიპოვე, ავტორმა უარი თქვა მის შემდგომ მხარდაჭერაზე. ამიტომ, მე გადავწყვიტე ყველაფერი მეკეთებინა, რადგან ამის გაკეთება არც ისე რთულია.

პირველი, რაც გასარკვევია, არის Sonatype-ის მოთხოვნები გამოცემისთვის. ისინი შემდეგია:

წყაროს კოდებისა და 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 მომხმარებლის სახელი и sonatypePassword ცვლადები, რომლებიც შეიცავს ლოგინს და პაროლს, რომელიც შეიქმნა რეგისტრაციის დროს sonatype.org.

ამრიგად ფინალი build.gradle ასე გამოიყურება:

სრული 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'). ჩვენ გამოვავლენთ მას ასამბლეის დროს და ავიღებთ მას ტეგის სახელიდან.

PGP გასაღების გენერაცია

Sonatype-ის ერთ-ერთი მოთხოვნაა, რომ ყველა ფაილი იყოს ხელმოწერილი GPG/PGP გასაღებით. ამისთვის მივდივართ აქ და ჩამოტვირთეთ GnuPG პროგრამა თქვენი ოპერაციული სისტემისთვის.

ჩვენ ვქმნით გასაღების წყვილს: gpg --gen-key, შეიყვანეთ მომხმარებლის სახელი, ელფოსტა და ასევე დააყენეთ პაროლი.
ჩვენ ვიგებთ id ჩვენი გასაღები ბრძანებით: gpg --list-secret-keys --keyid-format short. Id მითითებული იქნება ხაზის შემდეგ, მაგალითად: 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 მოქმედებების დაყენება

მოდით გადავიდეთ ფინალურ ეტაპზე, დავაყენოთ build და ავტომატურად გამოვაქვეყნოთ Github Actions-ის გამოყენებით.
Github Actions არის ფუნქცია, რომელიც საშუალებას გაძლევთ ავტომატიზირდეთ სამუშაო ნაკადის სრული CI / CD ციკლის განხორციელებით. შექმნა, ტესტირება და დანერგვა შეიძლება გამოწვეული იყოს სხვადასხვა მოვლენით: კოდის გაშვება, გამოშვების შექმნა ან პრობლემები. ეს ფუნქცია აბსოლუტურად უფასოა საჯარო საცავებისთვის.

ამ განყოფილებაში მე გაჩვენებთ, თუ როგორ უნდა დააყენოთ build და Push კოდი და განვათავსოთ Sonatype-ის საცავში გამოშვებისას, ასევე დააყენოთ საიდუმლოებები.

ჩვენ ვაყენებთ საიდუმლოებებს

ავტომატური შეკრებისა და განლაგებისთვის, ჩვენ გვჭირდება რიგი საიდუმლო მნიშვნელობები, როგორიცაა გასაღების ID, პაროლი, რომელიც შევიყვანეთ გასაღების გენერირებისას, თავად PGP გასაღები და Sonatype შესვლა/პაროლი. თქვენ შეგიძლიათ დააყენოთ ისინი სპეციალურ განყოფილებაში საცავის პარამეტრებში:

ჩვენ დავაყენეთ შემდეგი ცვლადები:

SONATYPE_USERNAME / SONATYPE_PASSWORD - შესვლა / პაროლი, რომელიც შევიყვანეთ Sonatype-ში რეგისტრაციისას
SIGNING_KEYID/SIGNING_PASSWORD — PGP გასაღების ID და პაროლი დაყენებულია გენერირების დროს.

მინდა უფრო დეტალურად ვისაუბრო GPG_KEY_CONTENTS ცვლადზე. ფაქტია, რომ გამოქვეყნებისთვის ჩვენ გვჭირდება პირადი PGP გასაღები. საიდუმლოებში გამოქვეყნების მიზნით გამოვიყენე ინსტრუქცია და დამატებით გააკეთა მთელი რიგი ქმედებები.

მოდით დავშიფროთ ჩვენი გასაღები gpg-ით: gpg --symmetric --cipher-algo AES256 9B695056.gpgპაროლის შეყვანით. ის უნდა განთავსდეს ცვლადში: SECRET_PASSPHRASE
მოდით გადავთარგმნოთ მიღებული დაშიფრული გასაღები ტექსტურ ფორმაში base64-ის გამოყენებით: 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, ასევე მოზიდვის მოთხოვნების შექმნისას.

სამუშაოების განყოფილება განსაზღვრავს ნაბიჯებს, რომლებიც უნდა შესრულდეს მითითებულ მოვლენებზე. ამ შემთხვევაში, ჩვენ ავაშენებთ ubuntu-ს უახლეს ვერსიას, გამოვიყენებთ Java 8-ს და ასევე გამოვიყენებთ დანამატს Gradle-ისთვის. eskatos/gradle-command-action@v1რომელიც, მშენებლის უახლესი ვერსიის გამოყენებით, გაუშვებს მითითებულ ბრძანებებს arguments. ცვლადები secrets.SONATYPE_USERNAME и secrets.SONATYPE_PASSWORD ეს არის საიდუმლოებები, რომლებიც ადრე ვიკითხეთ.

მშენებლობის შედეგები აისახება მოქმედებების ჩანართში:

ავტომატური განლაგება ახალი გამოშვების გამოშვებისას

მოდით შევქმნათ ცალკე სამუშაო პროცესის ფაილი ავტომატური განლაგებისთვის 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

განლაგების შედეგების შემოწმება Sonatype საცავში

გამოშვების შექმნის შემდეგ, წინა ნაწილში აღწერილი სამუშაო პროცესი უნდა დაიწყოს. ამისათვის შექმენით გამოცემა:

ტეგის სახელი უნდა დაიწყოს v-ით. თუ გამოქვეყნების გამოქვეყნების დაწკაპუნების შემდეგ სამუშაო პროცესი წარმატებით დასრულდა, ჩვენ შეგვიძლია გადავიდეთ სონატული Nexus რომ დარწმუნდეთ:

არტეფაქტი გამოჩნდა Staging საცავში. ის მაშინვე გამოჩნდება ღია სტატუსში, შემდეგ ხელით უნდა გადავიდეს Close სტატუსზე შესაბამისი ღილაკის დაჭერით. ყველა მოთხოვნის დაკმაყოფილების შემოწმების შემდეგ, არტეფაქტი გადადის დახურვის სტატუსში და აღარ არის ხელმისაწვდომი ცვლილებებისთვის. ამ ფორმით, ის დასრულდება MavenCentral-ში. თუ ყველაფერი კარგადაა, შეგიძლიათ დააჭიროთ ღილაკს რელიზიდა არტეფაქტი აღმოჩნდება Sonatype-ის საცავში.

იმისათვის, რომ არტეფაქტი მოხვდეს MavenCentral-ში, თქვენ უნდა მოითხოვოთ ის იმ ამოცანაში, რომელიც ჩვენ თავიდანვე შევქმენით. ამის გაკეთება მხოლოდ ერთხელ გჭირდებათ, ამიტომ ჩვენ პირველად ვაქვეყნებთ. შემდგომში ეს არ არის საჭირო, ყველაფერი ავტომატურად სინქრონიზდება. მათ სწრაფად ჩართეს სინქრონიზაცია, მაგრამ დაახლოებით 5 დღე დასჭირდა იმისთვის, რომ არტეფაქტი ხელმისაწვდომი ყოფილიყო MavenCentral-ში.

სულ ეს არის, ჩვენ გამოვაქვეყნეთ ჩვენი არტეფაქტი MavenCentral-ში.

სასარგებლო ბმულები

Მსგავსი სტატიის, გამოქვეყნება მხოლოდ maven-ის მეშვეობით
Დადგმა საცავი სონატიპი
Jira სონატიპი, რომელშიც უნდა შეიქმნას დავალება
მაგალითი საცავი, სადაც ყველაფერი დაყენებულია

წყარო: www.habr.com

Gradle და Github Actions-ის გამოყენება ჯავის პროექტის გამოსაქვეყნებლად Sonatype Maven ცენტრალურ საცავში