Azure Friday: Safeguard your containerized workloads using AKS backupAzure Friday:

I am happy to share a new episode of Azure Friday. It was an honor to appear along side Senior Product Manager Rajat Shrivastava in this episode to talk about AKS Backup. I this episode we joined Scott Hanselman to explore the functionality of AKS backup in safeguarding containerized apps and their data on AKS.

Backup is frequently overlooked, only gaining significance when a failure necessitates recovery. In the realm of Containers and Kubernetes, it is often perceived as unnecessary. However, the reality is that backups are essential even for containerized environments. Microsoft has introduced a backup solution for Azure Kubernetes Service (AKS) and its workloads, leveraging Azure Backup.

In this episode we dove into the importance of backing up containers, even when they are predominantly stateless. The episode sheds light on why safeguarding containers is crucial and provides insights into the workings of AKS backup in ensuring the protection of workloads running on AKS.

In the episode we also explore questions you may have about backing up K8s and we dive into demos showing how to protect AKS with AKS backup and how to do a restore. We even took time to answer this common question “Do I really need to backup my K8s cluster if I am running stateless apps & have everything in code i.e. IaC, CI/CD, or GitOps?”. The answer is yes. In fact one should think of it this way: “GitOps & K8s Backup are like Seatbelts & Airbags”. Here is a graphic to break this down further:

You can check out the episode here:

Addtional resources on AKS and AKS Backup:
■ Backup for AKS: Cloud native, Enterprise ready, Kubernetes aware backup – https://aka.ms/azfr/766/01
■ What is Azure Kubernetes Service backup? – https://aka.ms/azfr/766/02
■ Cluster extensions – https://aka.ms/azfr/766/03
■ Prerequisites for Azure Kubernetes Service backup using Azure Backup – https://aka.ms/azfr/766/04
■ Create a Pay-as-You-Go account (Azure) – https://aka.ms/azfr/766/payg
■ Create a free account (Azure) – https://aka.ms/azfr/766/free

Read more

From SysAdmin to Platform Engineer with Steve Buchanan on RunAsRadio

I was recently a guest on the RunAsRadio podcast. This was the second time being on the show. The last time was 4 years ago. You can catch the old episode here: Terraform vs Bicep/ARM with Steve Buchanan.

This new episode is #924 and is titled: “From SysAdmin to Platform Engineer with Steve Buchanan“. On this new episode we talked about Platform Engineering and a bunch of other stuff.

Here is the description from the episode:

Aren’t we all platform engineers? Steve Buchanan says yes!

But there’s more to it. Steve talks about the mindset of looking beyond individual products that we might have skills with and owning the entire problem of providing platforms for your organization to get work done.

The conversation dives into the many products that can help our applications function better and the challenge of making them secure and fast. Are containers the solution? Possibly!

It’s your platform; focus on the fundamentals and go further!

I had a great time chatting with Richard and we didn’t even mention AI until 40 minutes in. haha

You can check out the episode here:

https://runasradio.com/Shows/Show/924

or here:

Read more

New Platform Engineering Course and Blog

Many organizations have embraced DevOps and adopted technologies like Kubernetes, cloud computing, and Infrastructure as Code (IaC) tools like Terraform or Pulumi. Despite these efforts, they often face challenges in delivering on the promises of DevOps and cloud-native. Platform engineering has emerged as the next step in the evolution, breaking down barriers and empowering developers to bring software to the market faster and more efficiently.

Recently I have been working on content to help educate and share my knowledge in this space. I am happy to announce two new pieces of content on Platform Engineering including a new course and a new blog.

Course: Platform Engineering: The Big Picture

Last week my 22nd course was published on Pluralsight! I am really excited about this course because it covers something that has been really hot in tech lately. It is about Platform Engineering. Platform Engineering has emerged as the next step in the evolution, breaking down barriers and empowering teams. Being someone that works with Kubernetes and cloud native this course was right up my alley because I work directly in this space.

The course is titled “Platform Engineering: The Big Picture“. This course will help you explore platform engineering and discover how it can elevate cloud-native development, making developers’ lives easier while achieving new heights in software delivery. Platform Engineering unifies and centralizes toolchains & workflows for self-service making developers’ lives easier while achieving new heights in software delivery.

In this course, you will gain an understanding about Platform Engineering, its benefits, architecture, tooling, workflow and how to adopt it.

Some of the major topics covered in the course include:

  1. A Platform Engineering overview and why it’s needed, how Platforms enhance DevOps and streamline cloud native.
  2. A comparison of DevOps, SRE, and Platform Engineering.
  3. You will learn about Platform Engineering Architecture, its tooling landscape, and Internal Developer Platforms.

Check out the “Platform Engineering: The Big Picture“ course here:

https://www.pluralsight.com/courses/platform-engineering-big-picture

I hope you find value in this new Platform Engineering course. Be sure to follow my profile on Pluralsight so you will be notified as I release new courses

Here is the link to my Pluralsight profile to follow me:

https://www.pluralsight.com/authors/steve-buchanan

Blog: 8 tools every platform engineer should know about

I am also excited to announce my second Platform Engineering-related blog post on Pluralsight. This one is titled: “8 tools every platform engineer should know about”. In Platform Engineering there are a lot of tools that can make up a platform. It can be confusing and hard to know what tools to focus on in the Platform Engineering space. In this blog post, I list 8 tools that are a must-know when you are in the Platform Engineering space.

👉 Read the blog post here:

https://www.pluralsight.com/resources/blog/it-ops/top-platform-engineering-tools

Read more

Azure Friday: Exploring Automated Deployments for AKS with Steve Buchanan and Scott Hanselman

Hey everyone, today I’m super excited to tell you about a recent episode of Azure Friday that I was lucky enough to be a guest on.

Azure Friday is a weekly video series hosted by the legendary Scott Hanselman, where he interviews experts and developers on various Azure-related topics. In this episode, we talked about Automated Deployments for AKS, a new feature that makes it super easy to deploy your apps to Azure Kubernetes Service.

If you’re not familiar with AKS, it’s a managed Kubernetes service that lets you run containerized applications on Azure without having to worry about the complexity of managing the cluster. It’s a great way to scale your apps and take advantage of the benefits of Kubernetes, such as high availability, load balancing, and service discovery.

But what if you’re not familiar with containers or Kubernetes? What if you just have some code in a GitHub repo and you want to run it on AKS? That’s where Automated Deployments for AKS come in. It’s a feature that simplifies the Kubernetes development process by taking care of the tedious work of containerization for you. It uses a tool called Draft, which automatically detects the language and framework of your app, creates a Dockerfile and a Helm chart for you, builds and pushes the image to Azure Container Registry, and deploys the app to AKS. All with just a few clicks in the Azure Portal.

Sounds amazing, right? Well, that’s what I wanted to show Scott in this episode. I had an app hosted in a GitHub repo that I wanted to run on AKS. The app was a simple web app that displayed some data from a database. I had already created a few resources in Azure, such as a resource group, an Azure Container Registry, and an AKS cluster. All I needed to do was use Automated Deployments for AKS to get this app from code to running on a cluster.

So how did it go? Well, you’ll have to watch the episode to find out. But spoiler alert: it was super easy and fast. In just a few commands, I went from code to an app running on AKS. Scott was impressed and so was I. We had a great time chatting about how Automated Deployments for AKS works under the hood, some of the benefits and limitations of using it, and how it can help developers get started with containers and Kubernetes.

Check out the episode here:

https://aka.ms/azfr/749

With Automated Deployments, Microsoft is opening up new avenues for developers to embrace the power of containers and AKS, enabling them to effortlessly build scalable and robust applications.

If you’re interested in learning more about Automated Deployments for AKS, you can check out the documentation here: https://learn.microsoft.com/en-us/azure/aks/automated-deployments. It’s available today in public preview, so you can try it out for yourself and see how easy it is to run your apps on AKS.

That’s all for today. I hope you enjoy this episode of Azure Friday as much as I did. It was an honor and a pleasure to be a guest on Scott’s show and talk about one of my favorite topics: Azure Kubernetes Service. If you have any questions or feedback, feel free to leave a comment or reach out to me on Twitter at @Buchatech. Thanks for reading and happy coding!

Read more

Kubernetes Panel Event

In February Come Cloud With Us is hosting a Kubernetes panel with some of the industry’s BEST Kubernetes experts. I am honored and humbled to be one of the panelists. This panel consists of K8s experts from Dell, Google, Microsoft, Intercept, United Wholesale Mortgage, and Admincontrol. This is a global panel with panelists and hosts from the United States, Norway, United Kingdom, and Canada. Several of the panelists are also authors, Microsoft MVP’s and CNCF Ambassadors.

Here is a breakdown of the hosts and the panelists:

The hosts:

Abdul Kazi – Cloud Expert

Chris Gill – Cloud Expert and Microsoft MVP

The K8s Panelists:
Kristina Devochko – Microsoft Azure MVP
Kaslin Fields – Developer Advocate at Google
Kat Cosgrove – Lead Developer Advocate at Dell
Steve Buchanan – Principal Program Manager at Microsoft
Nills Franssens – Director of Digital and Application Innovation at Microsoft
Richard Hooper – Microsoft Azure MVP
Glen Belton – Kubernetes Platform Engineer

The panel will discuss Kubernetes and answer attendee questions. This will be a virtual event. This will be an event that you DON’T want to miss! Mark your calendars for the event on Thursday, February 16, 2023 4:00PM-5:30PM CST!

Register for the event here:

https://www.meetup.com/comecloudwithus/events/290494259

***Update

If you missed the live panel here is the recording for it:

Read more

Co-hosting 2 sessions in the Azure Hybrid Cloud Study Hall Series

I am very excited to be a part of a new Microsoft Azure Hybrid Cloud Study Hall series. This is a free fourteen-part weekly series that starts in April running through June.

In this study hall, you will learn how you can manage your on-premises, edge, and multi-cloud resources, and how you can deploy Azure services anywhere with Azure Arc and Azure Stack.

In this series, each session covers working with hybrid cloud resources using Azure services and hybrid cloud technologies. In these sessions we will:

  • Answer your questions live
  • Walk-through how to configure hybrid cloud resources
  • Walk-through how to deploy hybrid cloud resources
  • Walk-through how to manage hybrid cloud resources

In these sessions, together with you, we will work through Microsoft Learn modules focused on Azure Arc and Azure Stack HCI.

We have a solid lineup of speakers from Microsoft and the community! And I will be co-delivering two sessions myself.

Some of the speakers and moderators

Check out this video Microsoft marketing made where I talk about the sessions:

My sessions are:

Introduction to Azure Arc enabled Kubernetes

on May 5, 2022 10:00AM – 11:30AM (Pacific) co-hosting with Pierre Roman. 

Add to Calendar:
https://aka.ms/learnlive-azure-hybrid-cloud-study-hall-Ep7

The Learn Module:
https://aka.ms/learnlive-20220505A

Implement Azure App Service on Kubernetes with Arc

on June 9, 2022 10:00AM – 11:30AM (Pacific) co-hosting with Lior Kamrat.

Add to Calendar:
https://aka.ms/learnlive-azure-hybrid-cloud-study-hall-Ep11

The Learn Module:
https://aka.ms/learnlive-20220609A

Check out all of the Learn Live – Azure Hybrid Cloud Study Hall sessions here:

https://docs.microsoft.com/en-us/events/learntv/learnlive-azure-hybrid-cloud-study-hall

Read more

Cloudbusting Podcast Guest EP130 – Diving into Jucy Lucy, & Root Canal’s with a little Kubernetes, Azure Arc, & GitOps on the side

This was a fun podcast with Jez Ward, and Dave Chapman of Cloudreach. They run a podcast called Cloudbusting. On the podcast they focus on transformation, leadership, ways of working and emerging technology they explore the significant impact that cloud is having on people and businesses.

On this podcast episode, we set out to answer very important questions such as what are Jucy Lucy’s?, what are root Canals like today? oh, and yeah we also spend some time talking about what Containers, Kubernetes, & GitOps are and how they fit in the cloud.

Check out the podcast episode here:

https://www.cloudreach.com/en/podcasts/diving-into-kubernetes-azure-arc-gitops-episode-130

Read more

Speaking at DevOpsDays Minneapolis 2021

I have been attended DevOpsDays Minneapolis for 4 years. Its always a great event with rockstar speakers and great content. I also always meet some great folks in the DevOps space.

This year I will be speaking at DevOpsDays Minneapolis! This is a huge honor for me as I have a lot of respect for the event organizers and its always world-class event! I will be speaking about Kubernetes and GitOps. My session can be found here: https://devopsdays.org/events/2021-minneapolis/speakers/steve-buchanan

The event is July 20th-21st. It will be a hybrid event (in-person & virtual). I will be speaking in person on the 20th.

Here is my session info:

GitOps and Kubernetes: a Winning Combo

GitOps is an emerging pattern for cloud-native applications. This operating model simplifies Kubernetes ops while simultaneously improving the developer experience. GitOps enables continuous delivery of configuration updates and application deployments to Kubernetes.

Through the lens of GitHub, Argo CD, and Azure Kubernetes Service, we’ll explore use cases and benefits, principles and practices, architecture and tooling, and what GitOps changes in our day-to-day.

Check out the full program for the event here: https://devopsdays.org/events/2021-minneapolis/program

For those that won’t be attending in person you can Live stream it on YouTube here:

https://www.youtube.com/channel/UC_L5NW8kmClZyYz-HFgKsKA

———-Update 7/21/21———-

Today I delivered my session on GitOps and Kubernetes: a Winning Combo. This was my first in-person event since the pandemic in the US started. I went on stage right after Ian Coldwater gave the keynote. Ian had an amazing keynote talking about community, how the pandemic and the murder of George Floyd impacted Minneapolis last year along with how the community came together. I presented to a crowd of a few hundred as well as another couple hundred online.

The online reach of this event was amazing. I even received a message that my session was watched by some folks in Japan!

In my session, we went on a journey through how companies should focus on being software businesses moving to digital, how the pandemic accelerated companies and consumers going digital as well as companies using Kubernetes and GitOps as a way to help power digital transformation.

The conference organizers did a great job pulling off another excellent event while ensuring everyone followed safety guidelines.

Here is the stream recording of my session:

NOTE: If you are interested in learning more about GitOps check out my Pluralsight course titled “GitOps: The Big Picture” here: https://app.pluralsight.com/library/courses/gitops-the-big-picture

Read more

Guest on New Relic Observy McObservface Podcast – GitOps, Kubernetes, Linux on Azure, AI, Blockchain, and more

I was recently a guest on New Relic‘s Developer Relations team podcast “Observy McObservface” with Jonan Scheffler.

Jonan Scheffler and I talk about Microsoft’s Azure Kubernetes Service (AKS), Linux on Azure, how Microsoft’s been successful at working in enterprise and open source, where I believe GitOps & Kubernetes is eventually going to go, and my excitement in regards to AI and blockchain as well as how they’re going to impact the world. You can listen to the podcast and read the article links below.

Listen to the Podcast:
https://www.buzzsprout.com/1225223/8618776-open-is-not-optional-shifting-sands-and-faxing-on-blockchains-with-steve-buchanan

Read the Article:
https://www.therelicans.com/mandymoore/open-is-not-optional-shifting-sands-and-faxing-on-blockchains-with-steve-buchanan-495p

Read more

Build & release a Container Image from Azure DevOps to Azure Web App for Containers

I recently published a blog post on 4sysops.com about Web App for Containers on Azure here: https://4sysops.com/archives/web-app-for-containers-on-azure. That blog post is about the often-overlooked service in Azure that can be used to host a container/s on a web app in Azure App service.

This is a great service if you just need to run a single container or even a couple of containers that you have in Docker Compose. This service is PaaS and abstracts away an orchestration system like Kubernetes. If you need insight into the Azure App Service Web App for Containers service check out the blog post on 4sysops.

In this long blog post I am going to take things a step further and walk-through the build & release of a Container from Azure DevOps to Azure Web App for Containers. The overall goal of this post is to help someone else out if they want to setup a build and release pipeline for building and deploying a container to Azure App Service. We will use a very simple PHP web app I built that will run in the container.

Here are the components that are involved in this scenario:

  • Azure Container Registry (ACR): We will use this to store our container image. We will be pushing up the container image and pull it back down from the registry as a part of the build and release process.
  • Azure DevOps (ADO): This is the DevOps tooling we will use to build our container, push it up to ACR, pull it down into our release pipeline and then deploy to our Azure App Service.
  • App Service Web App for Containers: This is the web server service on Azure that will be used to host our container. Under the hood this will be a container that is running Linux and Apache to host the PHP web app.

Here is the data Flow for our containerized web app:

  1. Deploy the Azure App Service Web App for Containers instance
  2. Deploy the Azure Container Registry
  3. Deploy the Azure DevOps organization and project, create repository to host the code, clone repository in VS Code (Not shown in this blog post. Assume you know how to this up.)
  4. Update the application code (PHP code and Docker image) in Visual Studio code
  5. Commit application code from Visual Studio code to the Azure DevOps repo (Not shown in this blog post. Assume you know how to this up.)
  6. Setup build and then run container build and push the container image to ACR
  7.  Setup release pipeline and then kick off the release pipeline pulling down the container image from ACR and deploys the container to the App Service Web App for Containers instance.

Here is a diagram detailing out the build and release process we will be using:

Click to enlarge

Note that all code used in this blog post is hosted on my GitHub here: https://github.com/Buchatech/EOTD-PHP-APP-DOCKER-CONTAINER

Ok. Let’s get into the setup of core components of the solution and the various parts of the build and release pipeline.

For starters this solution will need a project in Azure DevOps with a repo. Create a project in Azure DevOps and a repo based on Git. Name the repo exerciseoftheday. Next up let’s create the core framework we need in Azure.

Deploy Azure App Service Web App for Containers

Let’s create the Azure App Service Web App for Containers that will be needed. We will need a resource group, an app service plan and then we can setup the app service. The PHP app we will be running is named Exercise Of The Day (EOTD) for short so our resources will use EOTD. Use the following steps to set all of this up.

We will do everything via Azure Cloud Shell. Go to https://shell.azure.com/ or launch Cloud Shell within VS Code.

Run the following Syntax:

# Create a resource group

az group create –name EOTDWebAppRG –location centralus

# Create an Azure App Service plan

az appservice plan create –name EOTDAppServicePlan –resource-group EOTDWebAppRG –sku S1 –is-linux

# Create an Azure App Service Web App for Containers

az webapp create –resource-group EOTDWebAppRG –plan EOTDAppServicePlan –name EOTD –deployment-container-image-name alpine

# Create a deployment slot for the Azure App Service Web App for Containers

az webapp deployment slot create –name EOTD –resource-group EOTDWebAppRG –slot dev –configuration-source EOTD

Deploy Azure Container Registry

Now let’s create the Azure Container Registry. Again, this is where we will store the container image. Run the following Syntax:

# Create Azure Container Registry

az acr create –resource-group EOTDWebAppRG –name eotdacr –sku Basic –admin-enabled false –location centralus

Note the loginServer from the output. This is the FQDN of the registry. Normally we would need this, admin enabled, and the password to log into the registry. In this scenario we won’t need admin enabled or the password because we will be adding a connection to Azure DevOps and the pipelines will handle pushing to and pulling the image from the registry.

When it’s all done you should see the following resources in the new resource group:

Next, we will need to build an application and a container image.

Read more