ಈ ಲೇಖನದಲ್ಲಿ, ಗ್ರ್ಯಾಡಲ್ ಬಿಲ್ಡರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸೋನಾಟೈಪ್ ಮಾವೆನ್ ಸೆಂಟ್ರಲ್ ರೆಪೊಸಿಟರಿಗೆ ಗಿಥಬ್ ಕ್ರಿಯೆಗಳ ಮೂಲಕ ಮೊದಲಿನಿಂದ ಜಾವಾ ಕಲಾಕೃತಿಯನ್ನು ಪ್ರಕಟಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಾನು ಹತ್ತಿರದಿಂದ ನೋಡಲು ಬಯಸುತ್ತೇನೆ.

ಒಂದೇ ಸ್ಥಳದಲ್ಲಿ ಸಾಮಾನ್ಯ ಟ್ಯುಟೋರಿಯಲ್ ಕೊರತೆಯಿಂದಾಗಿ ನಾನು ಈ ಲೇಖನವನ್ನು ಬರೆಯಲು ನಿರ್ಧರಿಸಿದೆ. ಎಲ್ಲಾ ಮಾಹಿತಿಯನ್ನು ವಿವಿಧ ಮೂಲಗಳಿಂದ ತುಂಡು ತುಂಡಾಗಿ ಸಂಗ್ರಹಿಸಬೇಕಾಗಿತ್ತು, ಮೇಲಾಗಿ, ಸಂಪೂರ್ಣವಾಗಿ ತಾಜಾ ಅಲ್ಲ. ಯಾರು ಕಾಳಜಿ ವಹಿಸುತ್ತಾರೆ, ಬೆಕ್ಕಿನ ಕೆಳಗೆ ಸ್ವಾಗತ.

ಸೋನಾಟೈಪ್‌ನಲ್ಲಿ ರೆಪೊಸಿಟರಿಯನ್ನು ರಚಿಸುವುದು

ಸೋನಾಟೈಪ್ ಮಾವೆನ್ ಸೆಂಟ್ರಲ್‌ನಲ್ಲಿ ರೆಪೊಸಿಟರಿಯನ್ನು ರಚಿಸುವುದು ಮೊದಲ ಹಂತವಾಗಿದೆ. ಇದಕ್ಕಾಗಿ ನಾವು ಹೋಗುತ್ತೇವೆ ಇಲ್ಲಿ, ನೋಂದಾಯಿಸಿ ಮತ್ತು ಹೊಸ ಕಾರ್ಯವನ್ನು ರಚಿಸಿ, ರೆಪೊಸಿಟರಿಯನ್ನು ರಚಿಸಲು ನಮ್ಮನ್ನು ಕೇಳುತ್ತದೆ. ನಾವು ನಮ್ಮಲ್ಲಿ ಓಡಿಸುತ್ತೇವೆ ಗುಂಪು ಐಡಿ ಯೋಜನೆ, ಪ್ರಾಜೆಕ್ಟ್ URL ಯೋಜನೆಯ ಲಿಂಕ್ ಮತ್ತು SCM url ಪ್ರಾಜೆಕ್ಟ್ ಇರುವ ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಗೆ ಲಿಂಕ್. ಗುಂಪು ಐಡಿ ಇಲ್ಲಿ com.example, com.example.domain, com.example.testsupport ರೂಪದಲ್ಲಿರಬೇಕು ಮತ್ತು ನಿಮ್ಮ ಗಿಥಬ್‌ಗೆ ಲಿಂಕ್‌ನ ರೂಪದಲ್ಲಿರಬಹುದು: github.com/yourusername -> io.github.yourusername. ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಈ ಡೊಮೇನ್ ಅಥವಾ ಪ್ರೊಫೈಲ್‌ನ ಮಾಲೀಕತ್ವವನ್ನು ಪರಿಶೀಲಿಸಬೇಕಾಗುತ್ತದೆ. ನೀವು ಗಿಥಬ್ ಪ್ರೊಫೈಲ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದರೆ, ಬಯಸಿದ ಹೆಸರಿನೊಂದಿಗೆ ಸಾರ್ವಜನಿಕ ರೆಪೊಸಿಟರಿಯನ್ನು ರಚಿಸಲು ನಿಮ್ಮನ್ನು ಕೇಳಲಾಗುತ್ತದೆ.

ದೃಢೀಕರಣದ ನಂತರ ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ, ನಿಮ್ಮ GroupId ಅನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಾವು ಮುಂದಿನ ಹಂತವಾದ 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.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'). ಅಸೆಂಬ್ಲಿ ಸಮಯದಲ್ಲಿ ನಾವು ಅದನ್ನು ಬಹಿರಂಗಪಡಿಸುತ್ತೇವೆ ಮತ್ತು ಟ್ಯಾಗ್ ಹೆಸರಿನಿಂದ ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ.

PGP ಕೀ ಉತ್ಪಾದನೆ

ಎಲ್ಲಾ ಫೈಲ್‌ಗಳು 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 ಕ್ರಿಯೆಗಳನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ಅಂತಿಮ ಹಂತಕ್ಕೆ ಹೋಗೋಣ, ಗಿಥಬ್ ಕ್ರಿಯೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಬಿಲ್ಡ್ ಮತ್ತು ಸ್ವಯಂ-ಪ್ರಕಟಣೆಯನ್ನು ಹೊಂದಿಸಿ.
Github ಕ್ರಿಯೆಗಳು ಪೂರ್ಣ CI / CD ಚಕ್ರವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ ಕೆಲಸದ ಹರಿವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಒಂದು ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ. ವಿವಿಧ ಈವೆಂಟ್‌ಗಳಿಂದ ನಿರ್ಮಿಸಲು, ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ನಿಯೋಜಿಸಲು ಪ್ರಚೋದಿಸಬಹುದು: ಕೋಡ್ ಪುಶ್, ಬಿಡುಗಡೆ ರಚನೆ, ಅಥವಾ ಸಮಸ್ಯೆಗಳು. ಸಾರ್ವಜನಿಕ ರೆಪೊಸಿಟರಿಗಳಿಗೆ ಈ ಕಾರ್ಯವು ಸಂಪೂರ್ಣವಾಗಿ ಉಚಿತವಾಗಿದೆ.

ಈ ವಿಭಾಗದಲ್ಲಿ, ಬಿಲ್ಡ್ ಮತ್ತು ಪುಶ್ ಕೋಡ್ ಅನ್ನು ಹೇಗೆ ಹೊಂದಿಸುವುದು ಮತ್ತು ಬಿಡುಗಡೆಯಾದ ನಂತರ ಸೋನಾಟೈಪ್ ರೆಪೊಸಿಟರಿಗೆ ನಿಯೋಜಿಸುವುದು ಮತ್ತು ರಹಸ್ಯಗಳನ್ನು ಹೊಂದಿಸುವುದು ಹೇಗೆ ಎಂದು ನಾನು ನಿಮಗೆ ತೋರಿಸುತ್ತೇನೆ.

ನಾವು ರಹಸ್ಯಗಳನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ

ಸ್ವಯಂಚಾಲಿತ ಜೋಡಣೆ ಮತ್ತು ನಿಯೋಜನೆಗಾಗಿ, ನಮಗೆ ಕೀ ಐಡಿ, ಕೀಲಿಯನ್ನು ರಚಿಸುವಾಗ ನಾವು ನಮೂದಿಸಿದ ಪಾಸ್‌ವರ್ಡ್, PGP ಕೀ ಸ್ವತಃ ಮತ್ತು ಸೋನಾಟೈಪ್ ಲಾಗಿನ್/ಪಾಸ್‌ವರ್ಡ್‌ನಂತಹ ಹಲವಾರು ರಹಸ್ಯ ಮೌಲ್ಯಗಳ ಅಗತ್ಯವಿದೆ. ನೀವು ಅವುಗಳನ್ನು ರೆಪೊಸಿಟರಿ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ವಿಶೇಷ ವಿಭಾಗದಲ್ಲಿ ಹೊಂದಿಸಬಹುದು:

ನಾವು ಈ ಕೆಳಗಿನ ಅಸ್ಥಿರಗಳನ್ನು ಹೊಂದಿಸಿದ್ದೇವೆ:

• SONATYPE_USERNAME / SONATYPE_PASSWORD - ಸೋನಾಟೈಪ್‌ನೊಂದಿಗೆ ನೋಂದಾಯಿಸುವಾಗ ನಾವು ನಮೂದಿಸಿದ ಲಾಗಿನ್ / ಪಾಸ್‌ವರ್ಡ್
• SIGNING_KEYID/SIGNING_PASSWORD — PGP ಕೀ ಐಡಿ ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ಪೀಳಿಗೆಯ ಸಮಯದಲ್ಲಿ ಹೊಂದಿಸಲಾಗಿದೆ.

ನಾನು 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, ಪುಲ್ ವಿನಂತಿಗಳನ್ನು ರಚಿಸುವಾಗ ಸಹ.

ಉದ್ಯೋಗಗಳ ವಿಭಾಗವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಈವೆಂಟ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಹಂತಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಉಬುಂಟುವಿನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯನ್ನು ನಿರ್ಮಿಸುತ್ತೇವೆ, ಜಾವಾ 8 ಅನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ಗ್ರೇಡಲ್‌ಗಾಗಿ ಪ್ಲಗಿನ್ ಅನ್ನು ಸಹ ಬಳಸುತ್ತೇವೆ 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 ನಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಹೆಸರಿನೊಂದಿಗೆ ಟ್ಯಾಗ್ ಅನ್ನು ರಚಿಸುವ ಘಟನೆಯಾಗಿದೆ.

ನಿಯೋಜನೆಯ ಮೊದಲು, ನಾವು ಪಿಜಿಪಿ ಕೀಲಿಯನ್ನು ರಹಸ್ಯಗಳಿಂದ ಹೊರತೆಗೆಯಬೇಕು ಮತ್ತು ಅದನ್ನು ಯೋಜನೆಯ ಮೂಲದಲ್ಲಿ ಇರಿಸಬೇಕು, ಹಾಗೆಯೇ ಅದನ್ನು ಡೀಕ್ರಿಪ್ಟ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಮುಂದೆ, ನಾವು ವಿಶೇಷ ಪರಿಸರ ವೇರಿಯಬಲ್ ಅನ್ನು ಹೊಂದಿಸಬೇಕಾಗಿದೆ 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 ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ಎಲ್ಲವೂ ಸರಿಯಾಗಿದ್ದರೆ, ನೀವು ಗುಂಡಿಯನ್ನು ಒತ್ತಬಹುದು ಬಿಡುಗಡೆ, ಮತ್ತು ಕಲಾಕೃತಿಯು ಸೊನಾಟೈಪ್ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ.

ಕಲಾಕೃತಿಯು ಮಾವೆನ್‌ಸೆಂಟ್ರಲ್‌ಗೆ ಪ್ರವೇಶಿಸಲು, ನಾವು ಪ್ರಾರಂಭದಲ್ಲಿಯೇ ರಚಿಸಿದ ಕಾರ್ಯದಲ್ಲಿ ನೀವು ಅದನ್ನು ಕೇಳಬೇಕು. ನೀವು ಇದನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಮಾಡಬೇಕಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾವು ಮೊದಲ ಬಾರಿಗೆ ಪ್ರಕಟಿಸುತ್ತೇವೆ. ನಂತರದ ಸಮಯಗಳಲ್ಲಿ, ಇದು ಅಗತ್ಯವಿಲ್ಲ, ಎಲ್ಲವನ್ನೂ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲಾಗುತ್ತದೆ. ಅವರು ನನಗೆ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅನ್ನು ತ್ವರಿತವಾಗಿ ಆನ್ ಮಾಡಿದರು, ಆದರೆ ಕಲಾಕೃತಿಯು ಮಾವೆನ್ ಸೆಂಟ್ರಲ್‌ನಲ್ಲಿ ಲಭ್ಯವಾಗಲು ಸುಮಾರು 5 ದಿನಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿತು.

ಅಷ್ಟೆ, ನಾವು ನಮ್ಮ ಕಲಾಕೃತಿಯನ್ನು ಮಾವೆನ್ಸೆಂಟ್ರಲ್ನಲ್ಲಿ ಪ್ರಕಟಿಸಿದ್ದೇವೆ.

ಉಪಯುಕ್ತ ಕೊಂಡಿಗಳು

• ಇದೇ ಲೇಖನ, ಮಾವೆನ್ ಮೂಲಕ ಮಾತ್ರ ಪ್ರಕಟಿಸಿ
• ವೇದಿಕೆ ಭಂಡಾರ ಸೊನಾಟೈಪ್
• ಜಿರಾ ಕಾರ್ಯವನ್ನು ರಚಿಸುವ ಸೋನಾಟೈಪ್
• ಉದಾಹರಣೆಗೆ ರೆಪೊಸಿಟರಿ ಅಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ಹೊಂದಿಸಲಾಗಿದೆ

ಮೂಲ: www.habr.com