Release Checklist 0.137.0: Ensure A Smooth Rollout

by Luna Greco 51 views

As we gear up for the 0.137.0 release, it's crucial to ensure a smooth and successful rollout. This release checklist serves as your comprehensive guide, covering everything from initial preparation to post-release tasks. Let's dive in and make sure we've got all our bases covered, guys! The release checklist is designed to ensure that every aspect of the release process is carefully considered and executed, minimizing the risk of errors or disruptions. This detailed guide will walk you through each stage, providing clear steps and checks to guarantee a successful deployment. By following this checklist, we can maintain the quality and reliability of our systems while delivering new features and improvements to our users.

Preparation: Laying the Groundwork for a Flawless Release

Before we even think about pushing the button, we need to make sure the groundwork is solid. Preparation is key to a flawless release, and it begins with meticulous planning and verification. This initial phase sets the stage for a successful deployment, ensuring that all prerequisites are met and potential issues are identified early on. A well-prepared release minimizes risks and ensures a smooth transition for both developers and end-users. Let's break down the steps to ensure we're all on the same page. Ensuring everything is in place before we start the deployment process not only saves time but also prevents potential headaches down the line. A thorough preparation phase is the cornerstone of a successful release, allowing us to confidently move forward with the deployment process.

  • [x] Milestone created

    First up, has the milestone been created? This is a critical step in our project management process. Creating a milestone helps us track progress and ensures that all tasks are aligned with the release goals. The milestone serves as a central point of reference for all related activities, making it easier to monitor progress and identify potential roadblocks. A well-defined milestone provides clarity and focus, helping the team stay on track and deliver the release on time. By creating a milestone, we establish a clear roadmap for the release, making it easier to manage dependencies and coordinate efforts. This initial step sets the tone for the entire release process, ensuring that we are organized and prepared for the tasks ahead. Let's make sure we've got this one checked off the list!

  • [ ] Milestone field populated on relevant issues

    Next, we need to populate the milestone field on all relevant issues. This ensures that every issue is correctly associated with the 0.137.0 release, providing a clear view of what's included. Linking issues to the milestone helps us track progress and ensures that no tasks are overlooked. By populating the milestone field, we create a comprehensive record of all work related to the release, making it easier to monitor progress and identify potential delays. This step is crucial for maintaining organization and ensuring that all team members are aligned on the scope of the release. Let's get those issues linked up, guys!

  • [ ] Nothing open for milestone

    It's super important that there are no open issues for the milestone. We want to make sure everything is wrapped up and ready to go before we proceed. This means addressing any outstanding bugs, features, or tasks that are associated with the release. Closing out all open issues ensures that we're delivering a stable and complete product. Before moving forward, it's crucial to review the milestone and verify that all tasks have been completed and closed. This step is a critical part of the release checklist, ensuring that we maintain quality and avoid introducing known issues into the new release. Let's double-check and confirm that we're all clear!

  • [ ] GitHub checks for branch are passing

    Make sure those GitHub checks are passing! We need to ensure that all automated checks, such as tests and linters, are green. Passing checks indicate that the code is in good shape and ready for release. This step helps us catch potential issues early, before they make it into the final product. GitHub checks provide an automated safety net, ensuring that our codebase meets the required standards and doesn't contain any critical errors. It's essential to resolve any failing checks before proceeding with the release. So, let's confirm that all checks are passing and that our code is ready to shine. These checks not only validate the code quality but also ensure that the integration process is smooth and free from conflicts.

  • [ ] No pre-release or snapshot dependencies present in build files

    We don't want any pre-release or snapshot dependencies sneaking into our build files. These can cause instability and unexpected behavior. It's important to verify that all dependencies are stable and officially released versions. This ensures that our release is built on a solid foundation and won't be affected by changes in pre-release versions. Before proceeding, it's crucial to thoroughly review our build files and confirm that all dependencies are pointing to stable releases. Let's keep our release clean and stable by avoiding any pre-release dependencies.

  • [ ] Verify HAPI protobuf dependency doesn't contain any unsupported fields or messages

    Let's verify that our HAPI protobuf dependency is squeaky clean. We need to ensure it doesn't contain any unsupported fields or messages that could cause compatibility issues. This is crucial for maintaining the integrity and reliability of our APIs. Unsupported fields or messages can lead to unexpected behavior or even break existing functionality. Before we release, it's essential to carefully review the HAPI protobuf dependency and confirm that it meets our requirements and doesn't introduce any risks. This step ensures that our APIs remain stable and functional for our users.

  • [ ] Automated Kubernetes deployment to integration successful

    Has the automated Kubernetes deployment to integration been successful? This is a key step in verifying our deployment process. A successful deployment to the integration environment indicates that our application can be deployed and run correctly in a Kubernetes cluster. This gives us confidence that our release will be deployable in production environments as well. Let's ensure that the automated deployment to integration is running smoothly before we move on.

  • [ ] No abnormal exceptions in importer logs in integration since the first SNAPSHOT

    We need to keep an eye on those importer logs in integration. No abnormal exceptions should be popping up since the first SNAPSHOT. This indicates that our importer is functioning correctly and not encountering any unexpected issues. Monitoring the logs helps us identify potential problems early on, before they can impact our users. Let's make sure those logs are clean and clear!

  • [ ] No breaking changes in API schema or behavior

    It's crucial that there are no breaking changes in our API schema or behavior. Breaking changes can cause compatibility issues and disrupt existing integrations. We need to ensure that our API remains stable and consistent for our users. Before releasing, it's essential to carefully review any API changes and confirm that they are backward-compatible. This step helps us maintain the trust and reliability of our platform.

  • [ ] Tag release

    Finally, let's tag the release! Tagging creates a snapshot of our code at a specific point in time, making it easy to track and manage different versions. A well-tagged release is essential for maintaining a clear history of our project and facilitating future updates and bug fixes. Let's get that tag in place and mark this milestone in our journey!

Release Candidates: Testing the Waters

Before we go all-in with the general release, we need to test the waters with release candidates. This phase is like a dress rehearsal, allowing us to identify and fix any last-minute issues before they affect the wider world. Release candidates are deployed in specific environments, such as previewnet, performance, and mainnet staging, to ensure that our release performs as expected under different conditions. This thorough testing process is crucial for maintaining the quality and reliability of our platform. Let's walk through the steps and make sure we're giving our release candidates the attention they deserve.

Previewnet: The First Line of Defense

Previewnet is our first line of defense, automatically deployed on every tag. This environment allows us to test new releases in a controlled setting before they reach the main network. By deploying to previewnet, we can catch potential issues early and minimize the risk of disruptions to our users.

  • [ ] Deployed
  • [ ] Helm Controller logs show successful reconciliation check
  • [ ] Helm release status is healthy

Performance: Pushing the Limits

Next up is the performance environment. This is where we put our release through its paces, ensuring it can handle the load and perform efficiently. Performance testing is critical for identifying bottlenecks and optimizing our application for real-world usage. Let's make sure our release can handle the heat!

  • [ ] Deployed
  • [ ] Helm Controller logs show successful reconciliation check
  • [ ] Helm release status is healthy
  • [ ] gRPC API performance tests
  • [ ] Importer performance tests

Mainnet Staging: The Final Dress Rehearsal

Mainnet staging is our final dress rehearsal before the big show. This environment closely mirrors our production setup, allowing us to test our release in a realistic setting. By deploying to mainnet staging, we can catch any last-minute issues and ensure a smooth transition to the live environment. This is our chance to iron out any wrinkles before we go live.

  • [ ] Deployed
  • [ ] Helm Controller logs show successful reconciliation check
  • [ ] Helm release status is healthy
  • [ ] No abnormal exceptions in importer logs
  • [ ] REST API performance tests
  • [ ] REST Java API performance tests
  • [ ] Web3 API performance tests

Generally Available: Releasing to the World

Now we're ready to release to the world! This is the moment we've been working towards, where our release becomes available to our users. But it's not just about pushing the button; we need to ensure a smooth rollout across all environments, from previewnet to mainnet. This phase requires careful coordination and monitoring to ensure that everything goes according to plan. Let's break down the steps and make sure we're ready for prime time.

  • [ ] Publish release
  • [ ] Publish marketplace release

Previewnet: Automatic Deployment

Previewnet gets deployed automatically on every tag, so we just need to confirm that everything is running smoothly.

  • [ ] Deployed
  • [ ] Helm Controller logs show successful reconciliation check
  • [ ] Helm release status is healthy

Testnet: Gradual Rollout

For testnet, we have a gradual rollout strategy. A GA tag triggers an automatic deployment to NA, and upon success, a PR for EU is automatically created. This allows us to monitor the deployment in stages and minimize the risk of widespread issues.

  • [ ] Latest Citus backup is successful
  • [ ] Deployed NA
  • [ ] Helm Controller logs show successful reconciliation check NA
  • [ ] Helm release status is healthy NA
  • [ ] Deployed EU
  • [ ] Helm Controller logs show successful reconciliation check EU
  • [ ] Helm release status is healthy EU

Pre-Production: Automated Deployments

Our pre-production environments are automatically deployed for any GA release. We just need to ensure that these deployments are successful.

  • [ ] Dev
  • [ ] Integration Docker
  • [ ] Staging Large
  • [ ] Staging Small

Mainnet: A Cautious Approach

Mainnet is the big one, so we take a cautious approach. We wait about a week after the testnet deployment to give it time to bake, then deploy to NA first. Upon success, a PR for EU is automatically created. This phased deployment allows us to monitor the release in a live environment and address any issues before they impact a large number of users. Let's make sure we're taking our time and doing it right!

  • [ ] Latest Citus backup is successful
  • [ ] Deployed NA
  • [ ] Helm Controller logs show successful reconciliation check NA
  • [ ] Helm release status is healthy NA
  • [ ] Deployed EU
  • [ ] Helm Controller logs show successful reconciliation check EU
  • [ ] Helm release status is healthy EU

Post Release: Tying Up Loose Ends

Once the release is out, we're not quite done yet. There are still a few post-release tasks to take care of to ensure everything is properly documented and up-to-date. This final phase is crucial for maintaining the integrity of our project and ensuring that future releases go smoothly. Let's tie up those loose ends and celebrate a successful release!

  • [ ] Update any completed HIPs to Final status and populate the release.

Conclusion: A Job Well Done!

And there you have it, guys! A comprehensive release checklist to guide us through a successful 0.137.0 rollout. By following these steps, we can ensure that our releases are smooth, stable, and ready for prime time. Let's keep up the great work and deliver an amazing experience to our users! This release checklist is not just a set of tasks; it's a roadmap to success. By adhering to these guidelines, we can minimize risks, maintain quality, and ensure that each release is a step forward for our platform. Remember, a well-executed release is a testament to our teamwork and dedication. Let's continue to work together to deliver exceptional results. A successful release checklist process ensures a stable and reliable system for our users. The meticulous steps outlined help us catch potential issues early, prevent disruptions, and maintain the integrity of our platform. By making this checklist a core part of our development cycle, we can consistently deliver high-quality releases that meet the needs of our community.