ਇਸ ਲੇਖ ਵਿਚ, ਮੈਂ ਗ੍ਰੇਡਲ ਬਿਲਡਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸੋਨਾਟਾਈਪ ਮਾਵੇਨ ਸੈਂਟਰਲ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਗਿਥਬ ਐਕਸ਼ਨ ਦੁਆਰਾ ਸਕ੍ਰੈਚ ਤੋਂ ਜਾਵਾ ਆਰਟੀਫੈਕਟ ਨੂੰ ਪ੍ਰਕਾਸ਼ਤ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ 'ਤੇ ਡੂੰਘਾਈ ਨਾਲ ਵਿਚਾਰ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ.

ਮੈਂ ਇਹ ਲੇਖ ਇਕ ਥਾਂ 'ਤੇ ਆਮ ਟਿਊਟੋਰਿਅਲ ਦੀ ਘਾਟ ਕਾਰਨ ਲਿਖਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ। ਸਾਰੀ ਜਾਣਕਾਰੀ ਵੱਖ-ਵੱਖ ਸਰੋਤਾਂ ਤੋਂ ਟੁਕੜੇ-ਟੁਕੜੇ ਇਕੱਠੀ ਕੀਤੀ ਜਾਣੀ ਸੀ, ਇਸ ਤੋਂ ਇਲਾਵਾ, ਪੂਰੀ ਤਰ੍ਹਾਂ ਤਾਜ਼ਾ ਨਹੀਂ। ਕੌਣ ਪਰਵਾਹ ਕਰਦਾ ਹੈ, ਬਿੱਲੀ ਦੇ ਹੇਠਾਂ ਸੁਆਗਤ ਹੈ।

ਸੋਨਾਟਾਈਪ ਵਿੱਚ ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਬਣਾਉਣਾ

ਪਹਿਲਾ ਕਦਮ ਸੋਨਾਟਾਈਪ ਮਾਵੇਨ ਸੈਂਟਰਲ ਵਿੱਚ ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਬਣਾਉਣਾ ਹੈ। ਇਸ ਲਈ ਅਸੀਂ ਜਾਂਦੇ ਹਾਂ ਇੱਥੇ, ਰਜਿਸਟਰ ਕਰੋ ਅਤੇ ਇੱਕ ਨਵਾਂ ਕੰਮ ਬਣਾਓ, ਸਾਨੂੰ ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਬਣਾਉਣ ਲਈ ਕਹੋ। ਅਸੀਂ ਆਪਣੇ ਵਿੱਚ ਗੱਡੀ ਗਰੁੱਪ ਆਈ.ਡੀ ਪ੍ਰੋਜੈਕਟ, ਪ੍ਰੋਜੈਕਟ URL ਪ੍ਰੋਜੈਕਟ ਲਿੰਕ ਅਤੇ SCM url ਵਰਜਨ ਕੰਟਰੋਲ ਸਿਸਟਮ ਲਈ ਇੱਕ ਲਿੰਕ ਜਿਸ ਵਿੱਚ ਪ੍ਰੋਜੈਕਟ ਸਥਿਤ ਹੈ। ਗਰੁੱਪ ਆਈ.ਡੀ ਇੱਥੇ com.example, com.example.domain, com.example.testsupport ਦੇ ਰੂਪ ਵਿੱਚ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਇਹ ਤੁਹਾਡੇ github ਦੇ ਲਿੰਕ ਦੇ ਰੂਪ ਵਿੱਚ ਵੀ ਹੋ ਸਕਦਾ ਹੈ: 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()
}

ਆਉ ਜੀਪੀਜੀ/ਪੀਜੀਪੀ ਦਸਤਖਤ ਸਥਾਪਤ ਕਰਨ ਲਈ, ਆਖਰੀ ਲੋੜ ਵੱਲ ਵਧੀਏ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਪਲੱਗਇਨ ਨਾਲ ਜੁੜੋ 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 ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:

ਪੂਰਾ 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

ਗਿਥਬ ਐਕਸ਼ਨ ਸੈਟ ਅਪ ਕਰ ਰਿਹਾ ਹੈ

ਆਉ ਅੰਤਮ ਪੜਾਅ 'ਤੇ ਚੱਲੀਏ, ਗਿਥਬ ਐਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਿਲਡ ਅਤੇ ਆਟੋ-ਪਬਲਿਸ਼ ਸੈਟ ਅਪ ਕਰੀਏ।
ਗਿਥਬ ਐਕਸ਼ਨ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਪੂਰੇ CI / CD ਚੱਕਰ ਨੂੰ ਲਾਗੂ ਕਰਕੇ ਵਰਕਫਲੋ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਬਿਲਡ, ਟੈਸਟ, ਅਤੇ ਡਿਪਲਾਇ ਵੱਖ-ਵੱਖ ਇਵੈਂਟਾਂ ਦੁਆਰਾ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ: ਕੋਡ ਪੁਸ਼, ਰੀਲੀਜ਼ ਰਚਨਾ, ਜਾਂ ਮੁੱਦੇ। ਇਹ ਕਾਰਜਕੁਸ਼ਲਤਾ ਜਨਤਕ ਰਿਪੋਜ਼ਟਰੀਆਂ ਲਈ ਬਿਲਕੁਲ ਮੁਫਤ ਹੈ।

ਇਸ ਭਾਗ ਵਿੱਚ, ਮੈਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗਾ ਕਿ ਬਿਲਡ ਅਤੇ ਪੁਸ਼ ਕੋਡ ਨੂੰ ਕਿਵੇਂ ਸੈਟ ਅਪ ਕਰਨਾ ਹੈ ਅਤੇ ਰੀਲੀਜ਼ ਹੋਣ 'ਤੇ ਸੋਨਾਟਾਈਪ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਕਿਵੇਂ ਤੈਨਾਤ ਕਰਨਾ ਹੈ, ਨਾਲ ਹੀ ਭੇਦ ਸਥਾਪਤ ਕਰਨਾ ਹੈ।

ਅਸੀਂ ਰਾਜ਼ ਸੈਟ ਕਰਦੇ ਹਾਂ

ਆਟੋਮੈਟਿਕ ਅਸੈਂਬਲੀ ਅਤੇ ਡਿਪਲਾਇਮੈਂਟ ਲਈ, ਸਾਨੂੰ ਕਈ ਗੁਪਤ ਮੁੱਲਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਕੁੰਜੀ ਆਈ.ਡੀ., ਪਾਸਵਰਡ ਜੋ ਅਸੀਂ ਕੁੰਜੀ ਬਣਾਉਣ ਵੇਲੇ ਦਰਜ ਕੀਤਾ ਸੀ, PGP ਕੁੰਜੀ ਖੁਦ, ਅਤੇ ਸੋਨਾਟਾਈਪ ਲੌਗਇਨ/ਪਾਸਵਰਡ। ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਰਿਪੋਜ਼ਟਰੀ ਸੈਟਿੰਗਾਂ ਵਿੱਚ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਭਾਗ ਵਿੱਚ ਸੈਟ ਕਰ ਸਕਦੇ ਹੋ:

ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਵੇਰੀਏਬਲ ਸੈਟ ਕਰਦੇ ਹਾਂ:

• SONATYPE_USERNAME / SONATYPE_PASSWORD - ਲੌਗਇਨ / ਪਾਸਵਰਡ ਜੋ ਅਸੀਂ Sonatype ਨਾਲ ਰਜਿਸਟਰ ਕਰਨ ਵੇਲੇ ਦਰਜ ਕੀਤਾ ਸੀ
• SIGNING_KEYID/SIGNING_PASSWORD — ਪੀਜੀਪੀ ਕੁੰਜੀ ਆਈਡੀ ਅਤੇ ਪਾਸਵਰਡ ਪੀੜ੍ਹੀ ਦੇ ਦੌਰਾਨ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ।

ਮੈਂ GPG_KEY_CONTENTS ਵੇਰੀਏਬਲ 'ਤੇ ਹੋਰ ਵਿਸਤਾਰ ਨਾਲ ਰਹਿਣਾ ਚਾਹੁੰਦਾ ਹਾਂ। ਤੱਥ ਇਹ ਹੈ ਕਿ ਪ੍ਰਕਾਸ਼ਨ ਲਈ ਸਾਨੂੰ ਇੱਕ ਪ੍ਰਾਈਵੇਟ PGP ਕੁੰਜੀ ਦੀ ਲੋੜ ਹੈ। ਭੇਦ ਵਿੱਚ ਇਸ ਨੂੰ ਪੋਸਟ ਕਰਨ ਲਈ, ਮੈਂ ਵਰਤਿਆ ਹਦਾਇਤ ਅਤੇ ਇਸ ਤੋਂ ਇਲਾਵਾ ਕਈ ਕਾਰਵਾਈਆਂ ਕੀਤੀਆਂ।

• ਆਉ ਜੀਪੀਜੀ ਨਾਲ ਸਾਡੀ ਕੁੰਜੀ ਨੂੰ ਐਨਕ੍ਰਿਪਟ ਕਰੀਏ: 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 ਇਹ ਉਹ ਭੇਦ ਹਨ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਪੁੱਛੇ ਸਨ।

ਬਿਲਡ ਨਤੀਜੇ ਐਕਸ਼ਨ ਟੈਬ ਵਿੱਚ ਪ੍ਰਤੀਬਿੰਬਤ ਹੋਣਗੇ:

ਜਦੋਂ ਇੱਕ ਨਵੀਂ ਰੀਲੀਜ਼ ਜਾਰੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ ਸਵੈ-ਤੈਨਾਤ ਕਰੋ

ਆਟੋਡਿਪਲਾਇ ਲਈ ਇੱਕ ਵੱਖਰੀ ਵਰਕਫਲੋ ਫਾਈਲ ਬਣਾਈਏ 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 ਅੱਖਰਾਂ ਨੂੰ ਕੱਟ ਦਿੱਤਾ ਹੈ। ਅੱਗੇ, ਅਸੀਂ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨ ਲਈ ਮਿਆਰੀ ਗ੍ਰੇਡਲ ਕਮਾਂਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ: test publish

ਸੋਨਾਟਾਈਪ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਤੈਨਾਤੀ ਨਤੀਜਿਆਂ ਦੀ ਜਾਂਚ ਕਰ ਰਿਹਾ ਹੈ

ਰੀਲੀਜ਼ ਬਣਨ ਤੋਂ ਬਾਅਦ, ਪਿਛਲੇ ਭਾਗ ਵਿੱਚ ਵਰਕਫਲੋ ਸ਼ੁਰੂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਇੱਕ ਰੀਲੀਜ਼ ਬਣਾਓ:

ਟੈਗ ਦਾ ਨਾਮ v ਨਾਲ ਸ਼ੁਰੂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਜੇਕਰ, ਪਬਲਿਸ਼ ਰੀਲੀਜ਼ 'ਤੇ ਕਲਿੱਕ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਵਰਕਫਲੋ ਸਫਲਤਾਪੂਰਵਕ ਪੂਰਾ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਜਾ ਸਕਦੇ ਹਾਂ ਸੋਨਟਾਈਪ ਗਠਜੋੜ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ:

ਆਰਟੀਫੈਕਟ ਸਟੇਜਿੰਗ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਪ੍ਰਗਟ ਹੋਇਆ। ਇਹ ਤੁਰੰਤ ਓਪਨ ਸਥਿਤੀ ਵਿੱਚ ਪ੍ਰਗਟ ਹੁੰਦਾ ਹੈ, ਫਿਰ ਇਸਨੂੰ ਢੁਕਵੇਂ ਬਟਨ ਨੂੰ ਦਬਾ ਕੇ ਹੱਥੀਂ ਬੰਦ ਸਥਿਤੀ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਜਾਂਚ ਕਰਨ ਤੋਂ ਬਾਅਦ ਕਿ ਸਾਰੀਆਂ ਲੋੜਾਂ ਪੂਰੀਆਂ ਹੋ ਗਈਆਂ ਹਨ, ਆਰਟੀਫੈਕਟ ਬੰਦ ਸਥਿਤੀ ਵਿੱਚ ਚਲਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਹੁਣ ਸੋਧ ਲਈ ਉਪਲਬਧ ਨਹੀਂ ਹੈ। ਇਸ ਰੂਪ ਵਿੱਚ, ਇਹ MavenCentral ਵਿੱਚ ਖਤਮ ਹੋ ਜਾਵੇਗਾ. ਜੇ ਸਭ ਠੀਕ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਬਟਨ ਦਬਾ ਸਕਦੇ ਹੋ ਰੀਲਿਜ਼, ਅਤੇ ਆਰਟੀਫੈਕਟ ਸੋਨਾਟਾਈਪ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਖਤਮ ਹੋ ਜਾਵੇਗਾ।

ਆਰਟੀਫੈਕਟ ਨੂੰ MavenCentral ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਉਸ ਕੰਮ ਵਿੱਚ ਇਸਦੀ ਮੰਗ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜੋ ਅਸੀਂ ਸ਼ੁਰੂ ਵਿੱਚ ਬਣਾਇਆ ਸੀ। ਤੁਹਾਨੂੰ ਇਹ ਸਿਰਫ਼ ਇੱਕ ਵਾਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ ਪਹਿਲੀ ਵਾਰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ। ਬਾਅਦ ਦੇ ਸਮੇਂ ਵਿੱਚ, ਇਸਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਸਭ ਕੁਝ ਆਪਣੇ ਆਪ ਹੀ ਸਮਕਾਲੀ ਹੋ ਜਾਵੇਗਾ। ਉਹਨਾਂ ਨੇ ਮੇਰੇ ਲਈ ਤੇਜ਼ੀ ਨਾਲ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਨੂੰ ਚਾਲੂ ਕਰ ਦਿੱਤਾ, ਪਰ ਕਲਾਤਮਕ ਸਮੱਗਰੀ ਨੂੰ MavenCentral ਵਿੱਚ ਉਪਲਬਧ ਹੋਣ ਵਿੱਚ ਲਗਭਗ 5 ਦਿਨ ਲੱਗ ਗਏ।

ਇਹ ਸਭ ਹੈ, ਅਸੀਂ MavenCentral ਵਿੱਚ ਆਪਣੀ ਕਲਾਕ੍ਰਿਤੀ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੀ ਹੈ.

ਉਪਯੋਗੀ ਲਿੰਕ

• ਸਮਾਨ ਲੇਖ, ਸਿਰਫ਼ maven ਦੁਆਰਾ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ
• ਸਟੇਜਿੰਗ ਰਿਪੋਜ਼ਟਰੀ ਸੋਨਾਟਾਈਪ
• Jira ਸੋਨਾਟਾਈਪ ਜਿਸ ਵਿੱਚ ਟਾਸਕ ਬਣਾਉਣਾ ਹੈ
• ਉਦਾਹਰਨ: ਰਿਪੋਜ਼ਟਰੀ ਜਿੱਥੇ ਇਹ ਸਭ ਸੈੱਟਅੱਪ ਹੈ

ਸਰੋਤ: www.habr.com