| # 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` |
| 3. * 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](https://docs.gradle.org/current/userguide/build_environment.html) 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. |
| |
| 4. 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. |
| 5. Check license criteria for [all dependencies](https://www.apache.org/legal/resolved.html) 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](https://docs.gradle.org/current/userguide/build_environment.html) 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} |
| ``` |
| 11. Create ZIP, DEB, RPM packages, .NET, Java and C++ client, sign them and create checksums: |
| ``` |
| ./gradlew -PprepareRelease prepareRelease -Pplatforms.enable |
| ``` |
| 12. 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](https://docs.docker.com/build/building/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 |
| ``` |
| 13. 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}` |
| 14. Copy all packages along with checksums and signatures to the development distribution directory: |
| ``` |
| cp packaging/build/release/* {dist.dev}/{version}-rc{rc} |
| ``` |
| 15. Check for ignite.version.full (TODO [IGNITE-IGNITE-26834](https://issues.apache.org/jira/browse/IGNITE-26834)), remove this step if it will be done automatically through gradle task. |
| 16. Commit ZIP and DEB\RPM packages: |
| ``` |
| cd {dist.dev} |
| svn add {version}-rc{rc} |
| svn commit -m “Apache Ignite {version} RC{rc}” |
| ``` |
| 17. Put the release on a vote on the developers mailing list. |
| 18. 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 |
| * Push to https://github.com/apache/ignite-website/tree/master/docs/ignite3 |
| 6. Build and publish API docs |
| * Java: `./gradlew aggregateJavadoc` |
| * .NET: `./gradlew :platforms:aggregateDotnetDocs` |
| * C++: `./gradlew :platforms:doxygenCppClient` |
| * Push to https://github.com/apache/ignite-website/tree/master/releases |
| 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: |
| * Get API key from https://svn.apache.org/repos/private/pmc/ignite/credentials/nuget.org (PMC only) |
| * `for i in *.nupkg; do dotnet nuget push $i -k API_KEY_HERE -s "https://nuget.org/"; done` |
| (PMC only) otherwise you need to request credentials from PMC-only area in SVN |
| 9. Publish Python packages (TODO [IGNITE-24327](https://issues.apache.org/jira/browse/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](https://ignite.apache.org/download.cgi) `_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](https://ignite.apache.org/blog/) 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. |