Daniel Hinojosa

Join us for a hands-on workshop, GitOps: From Commit to Deploy, where you’ll explore the entire lifecycle of modern application deployment using GitOps principles.

We’ll begin by committing an application to GitHub and watching as your code is automatically built through Continuous Integration (CI) and undergoes rigorous unit and integration tests. Once your application passes these tests, we’ll build container images that encapsulate your work, making it portable, secure, and deployment-ready. Next, we’ll push these images to a container registry preparing for deployment

Next, you will learn how to sync your application in a staging Kubernetes cluster using ArgoCD (CD), a powerful tool that automates and streamlines the deployment process. Finally, we’ll demonstrate a canary deployment in a production environment with ArgoCD, allowing for safe, gradual rollouts that minimize risk.

By the end of this workshop, you’ll have practical experience with the tools and techniques that perform GitOps deployments, so you can take this information and set up your deployments at work.

• Creating Your Application
• Running Locally
• Proper Commits
• Security Scans
• Safe Image Creation
• Image Publishing
• ArgoCD and Syncing
• Canary Deployments

Helm is excellent stuff. It is the package manager for Kubernetes and a way that you can package your Kubernetes YAML files and templatize them for reuse for either people in your organization or the public at large. Helm makes it super simple to deploy any major system with relative ease: find a repository, add the repository, and install your product. All Helm charts have a set of default values for everyday use cases, and it would be up to you to override the values you desire for your custom installation.

In this presentation, we will cover the following to get you going with Helm:

• Installation of Helm
• Adding a repository
• Installing a chart
• Upgrading and rolling back a chart
• Installing a dependency or subchart
• Creating charts
• Helm Functions
• Unit Testing
• Deployment

The road has been difficult for anyone who has attempted to do any database testing for the last 20 years. One solution that we tried was installing the test database. Oftentimes, that has been hard to maintain, particularly when that test database is shared. Another solution is to use DBUnit on a local system or, possibly, a shared system to set up the database as needed, test it, and tear it down. That too, was very hard to maintain. For many, it was just deploying your application and running end-to-end tests. If it works, it works, and we move on. With the advent of containerization, we now have something substantially better, test containers! Test containers give us the power to bring up a database that we need to test against and the exact version of the database.

With Test Containers, we can programmatically set the required database, possibly insert some data, and run our test against it. Behind the scene, test containers will load and cache the database so we may run the database subsequently and even faster. There are a multitude of databases to choose from, and it is also supported by multiple languages like Java, Go, Ruby, and more.

This presentation will explore ArgoCD, a powerful, open-source, and declarative GitOps continuous delivery tool for Kubernetes. We’ll introduce GitOps and its importance in modern DevOps practices, followed by a high-level overview of ArgoCD and its key features, such as automated sync and rollback capabilities. The presentation will cover ArgoCD’s architecture, detailing its core components and workflow, and provide a guide on installation, initial configuration, and defining and managing applications.

• Introduction of ArgoCD
• Architecture of ArgoCD
• Installing ArgoCD
• Creating and Managing Applications
• Integrating with CI
• Performing Rollbacks
• Performing Approvals

MLOps is a mix of Machine Learning and Operations. It is the new frontier for those interested in or knowledgeable about both of these disciplines. MLOps supports the operationalization of machine learning models developed by data scientists and delivers the model for processing via streaming or batch operations. Operationalizing Machine Learning Models is nurturing your data from notebook to deployment through pipelines.

In this workshop, we will describe the processes:

• Model Development
• Model Packaging
• Model Deployment
• Model Cataloging
• Model Monitoring
• Model Maintenance

Some of the technologies we will discover include:

• Airflow, Kubeflow, MLFlow
• Prometheus & Grafana
• TensorFlow, XGBoost,
• Serving
• Hyperparameter Tuning

Our exercises will include running and understanding MLFlow.

We have gone through a lot when it comes to configuring our computers with Java, with an editor, and maybe even setting up Git. We often take great care in ensuring that our PATH and even JAVA_PATH environments are clean and organized. Then, when we decide to install software that depends on the software that we already have installed, what does it do, reinstall that dependency! Not only that, it's somewhere else. Now we have multiple Java's with the same version. We have multiple pythons, Multiple everything. It's time to end this madness and aggravation and nix the old way and introduce a new way, NixOS.

In this presentation, we tell a story.

• I want my group to use the same language and tool versions exactly and repeatedly; I don't want to hear, “It works on my machine.” It should work on all machines and CI/CD.
• Wait, is this like Docker?
• Installing and Using Nix
• How to use nix-shell?
• Finding our software in the nix-store
• Establishing a default.nix
• How to install
• Using some of the other nix commands
• Programming Nix
• Using Nix with Docker
• How dependencies are cached
• What is the actual operating system? Nix-OS?

Canary Deployments are the last ingredient of any Continuous Delivery or Continuous Deployment rollout. A canary deployment is a deployment strategy that releases an application or service incrementally to a subset of users. All infrastructure in a target environment is updated in small phases (e.g., 2%, 25%, 75%, 100%). This control makes a canary release the lowest risk-prone compared to all other deployment strategies, like the blue-green strategy. If you need to back out of a production deployment quickly without much disruption, then canary deployments may be an excellent practice to set up.

We will treat this talk like a recipe so that you can set up a canary in your work environment.

• Continuous Integration, Continuous Delivery,
• Continuous Deployment Overview
• You can perform this anywhere: Cloud instances or Kubernetes
• What is Canary? What are some of the strategies you can use?
• What CD Frameworks perform Canary Deployments?
• How do you perform metrics? Are things going too slow or too fast?
• How do you back out if this rollout is not performing as well as it should?
• Can you perform canary deployments without a CD framework? Perhaps something native to Kubernetes?
• Performing using Spinnaker, Argo, Istio
• Conclusion