Apache Ignite 3 Release Procedure

This document describes the current procedure for preparing an Ignite 3 release.

Requirements

  1. Docker 19.03+
    • Verify docker installation: docker version
    • Verify docker buildx installation: docker buildx version
  2. .NET SDK 8.0.407+
    • Verify .NET installation: dotnet --version
    • Also some specific packages like: doxygen, no need to list them all, it`s easy enough to understand it from possible output errors.

Prerequisites

  1. Create a GPG key, upload it to a keyserver, and locate its ID. More details here: https://infra.apache.org/openpgp.html
  2. Checkout Apache distribution directories:
    svn checkout https://dist.apache.org/repos/dist/dev/ignite dist-dev
svn checkout https://dist.apache.org/repos/dist/release/ignite dist-release
  3. Provide your Apache credentials to Gradle (required for uploading to Apache Nexus) - create or update ~/.gradle/gradle.properties file with the following content:
    staging_user=*INSERT STAGING USERNAME HERE*
staging_password=*INSERT STAGING PASSWORD HERE*
    (do NOT put secrets into gradle.properties in the project dir - see Gradle docs for more details).

For all the commands going forward:

  • Replace {version} with the version number being released.
  • Replace {rc} with the current sequential number of the release candidate.
  • Replace {gpg} with your GPG key ID.
  • Replace {dist.dev} with the local path to the development distribution directory.
  • Replace {dist.release} with the local path to the release distribution directory.
  1. Collect all release important unresolved issues and label them release-{version}-blocker, inform the community that all further critical release issues need to be labeled appropriately. It is not necessary, but it allows don't to miss important issues.
  2. Check license criteria for all dependencies run ./gradlew :packaging:generateLicenseReport and check report ./packaging/build/reports/dependency-license.

Preparing the Release

  1. Go to the project home folder.
  2. Update RELEASE_NOTES.txt with the changes since the last release. Commit and push to the main branch.
  3. Update versions in main branch to the next development version (e.g., x.y.z-SNAPSHOT):
    • Update gradle.properties manually.
    • Run ./gradlew :platforms:updateVersion to update platforms versions (.NET, C++, Python, etc.)
    • Commit and push changes.
  4. Create and push a new branch for the release ignite-{version}.
  5. Update versions in ignite-{version} branch to the current release version, remove -SNAPSHOT suffix - same steps as in point 3.
  6. Create a Git tag from ignite-{version} branch head:
    git tag -a {version}-rc{rc} -m "{version}-rc{rc}"
git push --tags
  7. Setup Gradle properties - create or update ~/.gradle/gradle.properties file with the following content:
    signing.keyId=*INSERT KEY HERE LAST 8 CHARS*
signing.password=*INSERT PASSWORD HERE*
signing.secretKeyRingFile=*INSERT KEY RING ABSOLUTE PATH HERE*
    (do NOT put secrets into gradle.properties in the project dir - see Gradle docs for more details). To generate a secret key ring file use the following command
    gpg --keyring secring.gpg --export-secret-keys > ~/.gnupg/secring.gpg
    Show key id command (you need only last 8 chars from printed key)
    gpg -K
  8. Build the project, sign the artifact and create a staging repository:
    ./gradlew publishAllPublicationsToMavenRepository
  9. Login to the Apache Nexus and close the new repository: https://repository.apache.org/#stagingRepositories
  10. Create an empty folder under the development distribution directory:
rm -rf {dist.dev}/{version}-rc{rc}
mkdir {dist.dev}/{version}-rc{rc}
  1. Create ZIP, DEB, RPM packages, .NET, Java and C++ client, sign them and create checksums:
./gradlew -PprepareRelease prepareRelease -Pplatforms.enable
  1. Create Docker Images:
    ./gradlew :packaging:docker -Ptarget_platform=linux/amd64 -Pplatforms.enable
docker save apacheignite/ignite:{version} -o packaging/build/release/ignite:{version}-amd64.tar
./gradlew :packaging:docker -Ptarget_platform=linux/arm64 -Pplatforms.enable
docker save apacheignite/ignite:{version} -o packaging/build/release/ignite:{version}-arm64.tar
    Probably you will need some steps from multi-platform doc. Minimal steps during first release:
    docker buildx build --load -t linux/arm64 --builder=container .
docker run --privileged --rm tonistiigi/binfmt --install all
  2. ODBC: run appropriate TC suites:
    https://ci.ignite.apache.org/buildConfiguration/ApacheIgnite3xGradle_Release_Build_OdbcRpmPackage
https://ci.ignite.apache.org/buildConfiguration/ApacheIgnite3xGradle_Release_Build_7odbcDebPackage
    download artifacts, remove zip and sign all files with gpg key. After - copy into {dist.dev}/{version}-rc{rc}
  3. Copy all packages along with checksums and signatures to the development distribution directory:
cp packaging/build/release/* {dist.dev}/{version}-rc{rc}
  1. Check for ignite.version.full (TODO IGNITE-IGNITE-26834), remove this step if it will be done automatically through gradle task.
  2. Commit ZIP and DEB\RPM packages:
cd {dist.dev}
svn add {version}-rc{rc}
svn commit -m “Apache Ignite {version} RC{rc}”
  1. Put the release on a vote on the developers mailing list.
  2. If vote is passed - send appropriate message for dev-list, otherwise apply appropriate changes, don't forget to move git tag if there are code related changes git tag -d {version}-rc{rc}; git tag -a {version}-rc{rc} -m '{version}-rc{rc}'; git push --tags.

Finalizing the Release

Perform the following actions ONLY after the vote is successful and closed.

  1. Login to the Apache Nexus and release the staging repository: https://repository.apache.org/#stagingRepositories
  2. Create an empty folder under the release distribution directory:
    rm -rf {dist.release}/{version}
mkdir {dist.release}/{version}
  3. Copy ZIP packages along with checksums and signatures to the release distribution directory:
    cp {dist.dev}/{version}-rc{rc}/* {dist.release}/{version}
  4. Commit ZIP packages:
    cd {dist.release}
svn add {version}
svn commit -m “Apache Ignite {version}”
  5. Build and publish the documentation - see docs/README.adoc
  6. Build and publish API docs
  7. Publish Docker images:
    • ./gradlew :packaging:docker -Ptarget_platform=linux/amd64,linux/arm64 -Pdocker_push -Pplatforms.enable (PMC only) otherwise you need to request credentials from PMC-only area in SVN
  8. Publish NuGet packages:
  9. Publish Python packages (TODO IGNITE-24327)
  10. Update https://ignite.apache.org/download.cgi page - see https://cwiki.apache.org/confluence/display/IGNITE/Website+Development, https://cwiki.apache.org/confluence/display/IGNITE/How+to+Document
  11. https://github.com/apache/ignite-website/blob/master/docs/ignite3/available-versions.txt new version need to be first
  12. https://github.com/apache/ignite-website/blob/master/docs/ignite3/latest need to contain new version
  13. Update download links _src/_components/download-binary.pug and _src/_components/download-source.pug (and others if any were added). Copy the +downloadRow section and edit appropriately.
  14. Write a blog post announcing the release and listing the major changes and improvements. Add a new .pug file in _src/_blog.

Post Release steps

  1. Add compatibility snapshot, OpenAPI spec and update igniteVersions.json for released version:

    • On release git branch run the following command to generate new snapshot with compatibility information, copy OpenAPI spec and update the versions file ./gradlew postRelease
    • Switch git to main branch
    • Run compatibility test ./gradlew :ignite-runner:test --tests "org.apache.ignite.internal.configuration.compatibility.ConfigurationCompatibilityTest"
    • Add new files to git. Commit them under separate JIRA ticket with commit message {jira_ticket} Add compatibility data for Ignite {version}. Push the change to main branch.