TechPrufer
Get started
GitLab
GitLab logoGitLab · Feature trail

Release Management and Cadence

20 posts · Dec 2015 – Jan 2024

What this trail covers

GitLab's release management capabilities are enhanced with automated release note and changelog generation using commit trailers and the Changelog API. This allows for the creation of release artifacts, release notes, and comprehensive changelogs directly from CI/CD pipelines when a semantically versioned tag is pushed. The system leverages commit trailers like 'Changelog: added/changed/removed' to categorize changes, and the release-cli to create official releases with associated assets. The platform is evolving to include features like Deploy Freezes, allowing users to specify windows of time when deployments are not allowed for an environment, interlocking these policies within CI/CD and automation. This feature is configurable via the UI and leverages cron syntax for scheduling, with plans for group-level configuration and auditing.

All GitLab trails
  1. Pair GitLab and The Good Docs Project template to improve release notesThis post details how The Good Docs Project uses GitLab's milestone and issue tracking features to gather changes for release notes. It also describes the use of a Markdown template for crafting release notes and how these notes are added to GitLab releases. The post highlights the efficiency gained by combining GitLab's work management with a structured release notes template.
  2. Tutorial: Automate releases and release notes with GitLabThis post details the implementation of automated release note and changelog generation using commit trailers and the GitLab Changelog API. It introduces the concept of commit trailers for categorizing changes (added/removed/changed) and demonstrates how to configure a CI/CD pipeline with a `prepare_job` to fetch release notes via the Changelog API and a `release_job` using the `release-cli` to create the release. It also covers the process of pushing semantically versioned tags to trigger the pipeline and the structure of the generated release notes.
  3. How to adopt a cascading merge request strategy with GitLab FlowThis post introduces the `ucascade` bot, an open-source tool deployed on Kubernetes, to automate the cascading of merge requests across multiple release branches. It details the setup process involving project access tokens, Kubernetes deployment, webhook configuration, and the creation of a `ucascade.json` rule file. The bot's functionality is demonstrated through a test case where a change in the default branch automatically triggers the creation of merge requests in other release branches.
  4. Coordinating major documentation projects with GitLabThis post details how The Good Docs Project utilizes GitLab's project management features (milestones, scoped labels, health status, project boards) to manage their release cycle. It outlines their four-phase release process: Scheduling, Planning, Tracking, and Releasing. Specific technical details include using issue templates, scheduled pipelines, webhooks, GLQL, and project mirroring for onboarding contributors, and leveraging commit trailers and the Changelog API for automated release note generation. The post also highlights the use of a global project board for tracking progress and a burndown chart for release initiatives.
  5. How we increased our release velocity with GitLabEvolphin transitioned from Subversion to GitLab for source code management and version control. This move addressed challenges with their previous tedious, slow, and complicated branching and merging workflow, which resulted in a minimum of five weeks per product update. By adopting GitLab's free community version, they gained features for remote collaboration, feature branching, merge requests, and code review. This resulted in a more seamless, collaborative, and efficient workflow for their R&D teams, enabling them to execute feature releases two to three weeks faster and increasing overall release velocity by 30% to 40%. They now use GitLab as a single source of truth for source code, binary dependencies, and DevOps projects, integrating with Jenkins for CI/CD and YouTrack for issue tracking. Internal documentation and collaboration also leverage GitLab Wikis.
  7. Why iterative software development is criticalThis post introduces and advocates for the principle of iterative software development and Minimum Viable Change (MVC) within the context of shipping features and experiments. It uses the "suggest a pipeline" experiment as a case study to illustrate the benefits of smaller, faster iterations, such as faster value delivery, reduced risk, easier impact assessment, and quicker learning cycles. It contrasts this with a larger, less iterative approach. The post also describes how the "invite members" experiment is being approached using a "painted door test" to validate user interest before full development. The core technical contribution is the articulation of a development philosophy and its application to product development and experimentation.
  8. GitLab Version 12 Year In Review: Releases 12.0 to 12.10This post reviews the features and improvements released in GitLab versions 12.0 to 12.10. It highlights advancements in Dev (Productivity Analytics, Code Review Analytics, Code Quality Reports, Conan and NuGet repositories, DAGs, Parent-Child Pipelines), Sec (Dependency List, Security Dashboards, vulnerability management, Container Network Security), and Ops (Environments Dashboard, Merge Trains, group-level deploy tokens, HashiCorp Vault integration, EKS integration, Log Explorer). It also emphasizes the significant growth in community contributions and the ongoing DevSecOps vision.
  9. Inside GitLab: How we release software patchesThis post details the operational processes and technical mechanisms behind GitLab's software release and patch release workflows. It explains the roles and responsibilities of Release Managers within the Delivery team, differentiating between monthly self-managed releases and continuous auto-deployments on GitLab.com. Key technical aspects covered include the use of ChatOps for triggering patch release preparation, automation via GitLab CI/CD for release tasks, and the utilization of scheduled pipelines for GitLab.com updates. The post also discusses the criteria for issuing patch releases based on bug severity (S1/S2 vs. S3/S4) and the goal of reducing Mean Time To Production (MTTP) through automation and process streamlining.
  10. How GitLab is automating release generation in .gitlab-ci.ymlIntroduced the `release-cli` tool, a Go-based CLI application that automates the creation of GitLab Releases. This tool can be invoked directly within `.gitlab-ci.yml` jobs, leveraging `CI_JOB_TOKEN` and `CI_PROJECT_ID` to authenticate with the GitLab Releases API. The initial iteration supports creating releases with `--name` and `--description` parameters. Future enhancements planned include exposing `:release` YAML as steps, supporting file uploads to releases, binary file uploads, and automatic release note generation.
  11. Improving iteration and collaboration with user storiesThis post details the design and implementation process for the 'Deploy Freezes' feature within GitLab's Release Management. It highlights the use of user stories informed by customer research to define the MVC, focusing on UI-based configuration for less technical users. Key technical aspects include leveraging cron syntax for scheduling, reusing pipeline schedule capabilities, and integrating with CI/CD to prevent deployments during specified windows. The post also discusses the iterative design process, including user feedback and engineering proposals for retry mechanisms and UI notifications.
  12. HPublishing Android apps to Play Store with GitLab & fastlaneThis post details the integration of GitLab CI/CD with fastlane for automating the publishing of Android applications to the Google Play Store. It covers configuring fastlane for app metadata management, automated signing, versioning, and phased distribution. It also outlines setting up a Docker build environment with necessary dependencies and the Android SDK for consistent builds. Key technical aspects include using Gradle for build tasks, managing secrets via environment variables and configuration files, and leveraging fastlane actions like `supply` and `upload_to_play_store`.
  13. How to shorten the conversation cycleThis post introduces the concept of shortening the 'conversation cycle' for new features by measuring cycle time, adopting minimum viable changes (MVCs), involving gatekeepers early, and ensuring team buy-in. It advocates for breaking down large features into smaller, iterative releases to accelerate the time from idea to production and improve developer motivation through faster feedback.
  14. Feature Preview: Introducing Cycle AnalyticsIntroduced Cycle Analytics to measure the time from idea to production, breaking down the process into stages. This feature aims to help teams identify bottlenecks and improve overall cycle time for continuous improvement. The initial release will be part of GitLab 8.12.
  15. How we managed 49 monthly releasesThis post details GitLab's established monthly release cadence, which has been consistently followed since October 2011, reaching 49 releases by December 2015. It explains the rationale behind time-based releases for distributed software, highlighting benefits like predictability, user anticipation, and simplified communication. The post elaborates on the advantages of a monthly cycle, such as keeping development focused on smaller iterations and enabling quick feedback. It outlines the organizational structure where team members pick up tasks from a pool, guided by a published Direction document. The role of Release Manager is emphasized as a rotating responsibility rather than a fixed person, promoting reliability and process improvement. The post details the Release Manager's tasks, including coordinating activities, using a checklist, and appointing the next Release Manager. It also describes the steps leading up to a release, including creating release candidates, testing, deploying to GitLab.com, and preparing packages and blog posts. Finally, it discusses post-release activities, including handling regressions and patch releases, and reiterates the advantages of a timed release process for open-source projects, fostering trust and indicating active development.