Deploying at Scale with Jenkins

Software development is a strange craft. In some ways things seem to stay the same forever; we still sit at the same Unix command line from over 20 years ago and we use usually the same editors, but the software being developed feels pretty different. The constant theme over the last decade or more has been creating and delivering smaller and smaller chunks of new code, faster and faster. I used to develop code that wouldn’t be used by actual customers until more than a quarter after I originally wrote it. Today, it’s not unusual to get live feedback from customers for changes made just yesterday. By necessity, the steps required to safely move code from developer's laptop to a production server have become small, fast, and highly consistent via automation.

Recently, our team at Cerner automated deployments to deliver code to thousands of servers in production every week. In this session, I will walk through the decisions that I have had to make when building that pipeline and how we have used a very old Jenkins tool to solve the modern delivery puzzle.

Introduction to Jervis - Jenkins as a Service

In today’s ever-evolving technical world, **DevOps** has become a necessity. More organizations are embracing DevOps methodologies to take advantage of faster application delivery, enhanced innovation, stable operating environments, and performance-focused employee teams!

There are multiple trends and technologies contributing to the rise of DevOps. **Microservices, containers, and continuous everything** mean more frequent deployments to production. The only way to manage this without overworking is by automating the processes.

What empowers this automation is the massive progress/interests/awareness/investment in CI/CD tools. This, in theory, means that CI/CD platform tools need more love to succeed in this journey.

**Jenkins** is one such tool which is helping us achieve this goal. But unfortunately we don't have a better process or tools to manage Jenkins especially across the companies/organizations.

Why is it so hard to maintain or manage a Jenkins installation?

* Upgrading and maintaining Jenkins could be a tedious process.
* No change versioning, changes through Jenkins UI yields no record of what, when, why and by whom.
* Disaster Recovery could be nerve-wracking.
* Small change request could take days or even weeks to implement.
* No way to right away test a configuration.
* and just a lot of toil.

## What we need

* A simple and consistent framework to make **Everything as a Code**, which combines Jenkins and plugin(s) versions, config along with job configuration.
* Platform allows every team to build, test and run their own Jenkins seamlessly.
* Autonomy to manage it.

In this talk we are going to demo **Jervis**, an ecosystem we built at **Cerner** around Jenkins to address the aforementioned struggles. In short, the tool we use for automating builds and deployments has no way to automate its own management and focusses on dealing with this very problem.

## Audience Takeaway

How to best manage Jenkins and the continuous development ecosystem around it and ease the process of managing all configuration related to Jenkins as code to tackle the upgrades and downgrades with fashion.

## Target Audience

Jenkins Administrators, DevOps Engineers, SRE Engineers, Pipeline Developers, Software Engineers, and anyone who deals with building, releasing and deploy code through Jenkins and has felt the CI/CD process needed improvements as well as a certain degree of robustness.

Infrastructure as Code with Terraform

Building infrastructure with automation tools (Infrastructure as Code) has become the new normal for both on-prem and cloud environments, gained a lot in popularity lately and is the thing you need to master if you are or about to get into a Ops / DevOps role.

One of the most popular open-source infrastructure automation tools in the market is Terraform from HashiCorp. In this workshop you'll learn how to use terraform to automate your infrastructure. I will first show you the basics of terraform and will then explain how to automate infrastructure on AWS using terraform.

* Introduction to IaC (Infrastructure as Code).
* Terraform Concepts, modules, state.
* Managing multiple environments.
* Terraform alternatives, new trends and tools to watch for in 2023 and beyond.

## Prerequisites

* AWS Account (AWS Free Trial is good)
* Install Terraform, AWS CLI
* Be ready to get your mind blown by IaC

## Target Audience

Ops/IT Engineers, DevOps Engineers, SRE Engineers, Software Engineers, and anyone who deals with building Cloud infrastructure (AWS).

Publish Your Docs As a Champ

It would not be an exaggeration to say that we do most of our learning by reading some type of documentation. It is hard to over-emphasize how important technical documentation is to minimize headaches while trying to create, build or maintain a piece of software.

Either you are a developer just getting started on a new project, an operations engineer trying get through the deployment process, a support engineer swimming through the ocean of info/reports/logs to find a root cause for the problem in production environment or a manager trying to make sure the entire project is on track, having easy access to correct, complete and up-to-date documentation makes a huge difference.

However, there are few challenges to maintain documentation:
* Nowhere near the code they intend to represent and describe.
* Spread across the projects and tools.
* Searching is the hard part.
* And before we even realize it, the docs goes stale and outdated.

Some of these problems could easily be avoided by managing the docs along with source code, among a lot of options, GitHub Pages seems to the best and easiest way to achieve this, however it brings more challenges with it like building and publishing docs across projects or organizations. Automating this is even more challenging unless we have a set of better process and tools around this.

In this presentation we are going to talk more about various options to publish docs through GitHub pages and how to make your documentation (including service api docs, wikis, blogs, presentations and/or demo videos) live with your source code like a champ.

I plan to demo a working solution to make it easier to maintain and publish documentation in an enterprise that follows agile methodology.

Tools that empower this solution are GitHub Pages, Hugo, GitHub Apps, Jenkins and a few other tools available in an enterprise.

Audience Takeaway:
Maintain documentation without having to worry about where to find it. How to adopt this framework and a set of practices and ideas to start building their own team's high quality technical documentation.

*Accio!* Cross-platform Desktop apps

In a perfect world, developers write code once and it just works everywhere. Unfortunately, that utopia doesn't exist. Instead, developers practice their wizardry in a digital universe that includes multiple versions of competing operating systems. Attempting to build a cross-platform desktop application—that is, one which will run on multiple operating systems using the same underlying code—presents a number of challenges, especially for the developer with limited resources. Those of us short on resources need help to reach our end-goal. Just as Harry had Dumbledore, Ron, and Hermione to help him defeat Voldemort, we too have help -- in the form of a cross-platform framework. Cross-platform frameworks - which include Electron, NWJS and CEF - are designed to limit the work that a developer or development team has to put in to creating apps for Windows, Mac OS and Linux.

In this talk, I will walk through the decisions that I have had to make when building my own application -- Enterprise Flashlight (Echelon) -- including but not limited to: pros and cons of using Electron over other frameworks and finally will give a demo on the application I developed, which aims to increase the productivity of all engineer at my current company.

Target Audience:
This talk will be useful for any muggle who is on a quest to build cross platform desktop applications.

Nightmare to Non-Event: Releasing Maven Projects with Jenkins Pipeline At Scale

A release tool that is reusable, scalable, and transparent is a requirement for high magnitude development efforts. Used effectively, Jenkins Pipeline can transform a nightmare into a non-event. This talk discusses real world strategies for executing CI/CD with Maven, Git, Jira, and Jenkins Pipeline.

Development teams commonly couple their release process with the agile development cycle. This has the potential to be a time consuming and error prone process, eating away at precious development capacity. At small scale, such as a standalone open source project, the cost may be overlooked. At a grand scale, say 100+ projects across cooperating teams in a Line of Business, the effort quickly becomes unmanageable.

Hiccups in the release process that previously may have been an edge case, now have the potential to bottleneck a dependency needed by half a dozen teams. Coordinating major/minor/patch versions from master, the latest tag, or an old tag commonly result in a late night support call. Maintaining a release DAG becomes a chore. Performing releases from a development machine simply aren’t feasible. Monitoring and troubleshooting become an overnight affair. Issue tracking systems become overwhelming to work with, adding to the risk of violated process checks.

This presentation demonstrates strategies to implement a Jenkins Pipeline for releases. Such a pipeline can execute a standard Maven release process, interact with Jira in an automated fashion, leverage existing communication channels to inform teams of issues, and achieve continuous delivery.

The target audience is members of a development organization who are responsible for a release at any level.

Familiarity with Jira will be beneficial, however concepts will translate well to many similar issue tracking tools. Familiarity with Git and Maven, at an operational level, will be assumed.

ChatOps over CI/CD using Jenkins Pipeline

Hubot Pipeline Steps is a plugin in Jenkins Pipeline suite that enables users to perform operational tasks, over chat, for Continuous Integration/Delivery framework.

Through the hum of operational buzzwords, ChatOps is a rising star. It is a paradigm which seeks to give engineers all the tools needed for task automation, incident remediation, event driven collaboration, and more. Overall it has the potential to minimize engineering time spent on things-not-engineering.

Popular CI/CD tools such as Jenkins Pipeline support one or many chat platforms. However maintaining an evolving set of key plugins and scripts is difficult to duplicate consistently. Eventually, like any copied code, tasks defined for at least one chat engine fall out of sync. Unfortunately converging on a single communications application is rarely an easy task, due to advocates arguing over Slack (because Slack), HipChat (because Atlassian is central to your workflow), and Microsoft Teams (because everyone BUT engineering uses Office365).

This talk will present the Hubot Steps plugin for Jenkins Pipeline as a solution to the aforementioned struggles. It will provide: a brief overview of CI/CD using Jenkins Pipeline, ChatOps using Hubot, a close look at the Hubot Steps plugin, and a live demo of these tools in action.

The target audience for this talk is anyone interested in implementing Jenkins and Hubot in their CI/CD workflow. Some concepts described will be applicable to other frameworks. Familiarity with Jenkins Pipelines and Hubot will be beneficial to audience members.

Automate Everything: A Deep Dive into Jenkins Pipelines

The Jenkins Pipeline plugin is a game changer for Jenkins users. Based on a Domain Specific Language (DSL) in Groovy, the Pipeline plugin makes pipelines scriptable and it is an incredibly powerful way to develop complex, multi-step DevOps pipelines. These Pipelines are becoming the standard way to programmatically specify your CI flow, in this talk we will demo following things in detail:

* Introduction to Jenkins Pipeline.
* Scripted vs Declarative.
* Shared Pipeline Libraries.
* Pipeline as YAML.
* Best Practices.
* Tips and Tricks.

The target audience is members of a development organization who are using Jenkins pipelines or planning to use to advance the CI/CD journey.

Successful Git Workflows That Work

Version management with git makes branching and merging much easier than before. This allows a wide variety of branching strategies and workflows. Almost all of these are an improvement over the methods used before git. But many of us end up with a workflow that is not clearly defined, overly complex or not integrated with rest of the dev ecosystem.

In this talk, we will go through various workflows in detail and explain when each is best, those are:

* Git flow
* Github flow
* Gitlab flow
* and other flows those actually work with CI/CD model.

The target audience is members of a development organization who are ready to start using Git or already using git and would like to make their CI/CD journey a success story.