Getting Started with GitHub Copilot for DevOps: Building Your Azure Lab with Vibe Coding

Most of the Copilot writing I found when I started was about application code. I wanted to know whether the same loop held up against infrastructure, where a wrong guess costs you a deployment instead of a unit test. So I built an Azure lab with it and took notes. This is the walkthrough.

What is Vibe Coding and Why GitHub Copilot for DevOps?#

Vibe coding is a creative, exploratory approach to coding where you let your intuition and AI assistance guide you through rapid prototyping and iterative development. Instead of meticulously planning every detail upfront, you start with a general direction and let the code evolve naturally with the help of intelligent suggestions.

GitHub Copilot brings this philosophy to DevOps by:

• Suggesting Infrastructure as Code (IaC) templates and configurations
• Auto-completing complex YAML workflows and scripts
• Helping you discover best practices through intelligent code suggestions
• Accelerating the learning curve for new technologies and services

For DevOps engineers, this means you can rapidly prototype infrastructure, experiment with new services, and build automation pipelines you trust without stalling on syntax and documentation.

Setting Up Your Azure DevOps Lab#

Set up the Azure foundation first. This guide assumes you’re comfortable with engineering fundamentals but new to Azure.

Step 1: Create Your Azure Account#

If you don’t already have an Azure account, start with the free tier:

1. Visit azure.microsoft.com/free
2. Click “Start free” and follow the registration process
3. You’ll get $200 in credits and access to free services for 12 months

Step 2: Azure Portal Familiarization#

Once your account is active:

1. Navigate to portal.azure.com
2. Explore the main dashboard and navigation menu
3. Create your first resource group for organization:

# We'll use this resource group throughout the tutorial
Resource Group Name: copilot-devops-lab
Region: East US

Step 3: Install Azure CLI#

The Azure CLI is essential for automation and scripting. Install it on your local machine:

Windows:

# Using PowerShell
Invoke-WebRequest -Uri https://aka.ms/installazurecliwindows -OutFile .\AzureCLI.msi
Start-Process msiexec.exe -Wait -ArgumentList '/I AzureCLI.msi /quiet'

macOS:

# Using Homebrew
brew update && brew install azure-cli

Linux:

# Using curl
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

Verify installation and login:

az --version
az login
az account show

Step 4: Set Up Your Development Environment#

For the best Copilot experience, ensure you have:

• Visual Studio Code with the GitHub Copilot extension
• Azure Tools for VS Code
• Bicep extension for Azure IaC

Copilot-Assisted Infrastructure as Code#

Now use GitHub Copilot to scaffold the infrastructure. We’ll explore both Bicep and Terraform approaches.

Scaffolding with Bicep#

Create a new file main.bicep and let Copilot guide you:

// Start typing: "Create a resource group and storage account for a DevOps lab"
// Copilot suggestion:

@description('Location for all resources')
param location string = resourceGroup().location

@description('Environment name (dev, staging, prod)')
param environment string = 'dev'

@description('Project name for resource naming')
param projectName string = 'copilotlab'

// Resource group is managed at deployment scope
// Storage account for artifacts and state
resource storageAccount 'Microsoft.Storage/storageAccounts@2023-01-01' = {
  name: '${projectName}${environment}storage'
  location: location
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'StorageV2'
  properties: {
    accessTier: 'Hot'
    allowBlobPublicAccess: false
    supportsHttpsTrafficOnly: true
  }
}

// Virtual network for our lab environment
resource virtualNetwork 'Microsoft.Network/virtualNetworks@2023-04-01' = {
  name: '${projectName}-${environment}-vnet'
  location: location
  properties: {
    addressSpace: {
      addressPrefixes: [
        '10.0.0.0/16'
      ]
    }
    subnets: [
      {
        name: 'default'
        properties: {
          addressPrefix: '10.0.1.0/24'
        }
      }
    ]
  }
}

output storageAccountId string = storageAccount.id
output vnetId string = virtualNetwork.id

Alternative: Terraform Approach#

If you prefer Terraform, create main.tf and let Copilot assist:

# Configure the Azure Provider
terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.0"
    }
  }
}

# Configure the Microsoft Azure Provider
provider "azurerm" {
  features {}
}

# Create a resource group
resource "azurerm_resource_group" "main" {
  name     = "copilot-devops-lab"
  location = "East US"

  tags = {
    Environment = "Development"
    Project     = "Copilot-DevOps-Lab"
  }
}

# Create a storage account
resource "azurerm_storage_account" "lab_storage" {
  name                     = "copilotlabstorage"
  resource_group_name      = azurerm_resource_group.main.name
  location                 = azurerm_resource_group.main.location
  account_tier             = "Standard"
  account_replication_type = "LRS"

  tags = {
    Environment = "Development"
    Project     = "Copilot-DevOps-Lab"
  }
}

Copilot-Assisted Azure Resource Creation#

Let’s create a simple web application infrastructure using Copilot’s assistance. Start typing a comment and watch the magic happen:

// Create an App Service plan and web app for hosting a simple application
// Copilot will suggest something like:

@description('App Service Plan SKU')
param appServicePlanSku string = 'B1'

@description('Web app name')
param webAppName string = '${projectName}-${environment}-webapp'

// App Service Plan
resource appServicePlan 'Microsoft.Web/serverfarms@2023-01-01' = {
  name: '${projectName}-${environment}-asp'
  location: location
  sku: {
    name: appServicePlanSku
  }
  kind: 'linux'
  properties: {
    reserved: true
  }
}

// Web App
resource webApp 'Microsoft.Web/sites@2023-01-01' = {
  name: webAppName
  location: location
  properties: {
    serverFarmId: appServicePlan.id
    siteConfig: {
      linuxFxVersion: 'NODE|18-lts'
      appSettings: [
        {
          name: 'WEBSITE_NODE_DEFAULT_VERSION'
          value: '18-lts'
        }
        {
          name: 'ENVIRONMENT'
          value: environment
        }
      ]
    }
    httpsOnly: true
  }
}

output webAppUrl string = 'https://${webApp.properties.defaultHostName}'

Deploy this infrastructure:

# Create a resource group first
az group create --name copilot-devops-lab --location "East US"

# Deploy the Bicep template
az deployment group create \
  --resource-group copilot-devops-lab \
  --template-file main.bicep \
  --parameters projectName=copilotlab environment=dev

GitHub Actions CI/CD Pipeline#

Now let’s automate deployments with GitHub Actions. Create .github/workflows/azure-deploy.yml:

name: Deploy to Azure

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

env:
  AZURE_RESOURCE_GROUP: copilot-devops-lab
  AZURE_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

jobs:
  deploy-infrastructure:
    runs-on: ubuntu-latest
    
    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Azure Login
      uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}

    - name: Deploy Bicep template
      uses: azure/arm-deploy@v1
      with:
        scope: resourcegroup
        subscriptionId: ${{ env.AZURE_SUBSCRIPTION_ID }}
        resourceGroupName: ${{ env.AZURE_RESOURCE_GROUP }}
        template: ./infrastructure/main.bicep
        parameters: |
          projectName=copilotlab
          environment=dev

    - name: Deploy Application
      uses: azure/webapps-deploy@v2
      with:
        app-name: copilotlab-dev-webapp
        package: ./app

  test-deployment:
    needs: deploy-infrastructure
    runs-on: ubuntu-latest
    
    steps:
    - name: Test web app endpoint
      run: |
        curl -f https://copilotlab-dev-webapp.azurewebsites.net/health || exit 1

Setting up Azure Credentials#

To authenticate GitHub Actions with Azure, create a service principal:

# Create service principal
az ad sp create-for-rbac \
  --name "github-actions-copilot-lab" \
  --role contributor \
  --scopes /subscriptions/$SUBSCRIPTION_ID/resourceGroups/copilot-devops-lab \
  --sdk-auth

# Copy the JSON output to GitHub Secrets as AZURE_CREDENTIALS

Add these secrets to your GitHub repository:

• AZURE_CREDENTIALS: The JSON output from the service principal creation
• AZURE_SUBSCRIPTION_ID: Your Azure subscription ID

Maintaining and Iterating Your Lab#

Copilot Tips for Ongoing Development#

1. Use descriptive comments: Copilot works best when you describe your intent clearly

   // Create a Key Vault for storing application secrets with RBAC enabled

2. Use Copilot for troubleshooting: When you encounter errors, describe the issue in comments

   # Fix the deployment error where the storage account name is too long

3. Experiment with different patterns: Let Copilot suggest alternative approaches

   // Suggest a more cost-effective storage configuration for development

Infrastructure Evolution Strategies#

Version your infrastructure: Use Git tags to version your infrastructure deployments:

# Tag your stable infrastructure versions
git tag -a v1.0.0 -m "Initial lab infrastructure"
git push origin v1.0.0

Environment promotion: Create separate parameter files for different environments:

infrastructure/
├── main.bicep
├── parameters/
│   ├── dev.parameters.json
│   ├── staging.parameters.json
│   └── prod.parameters.json

Monitor and optimize: Use Azure Cost Management and Copilot to optimize your resources:

// Suggest cost optimization strategies for this storage account configuration
resource optimizedStorage 'Microsoft.Storage/storageAccounts@2023-01-01' = {
  // Copilot will suggest appropriate tier and redundancy options
}

Advanced Patterns with Copilot#

Multi-Service Architecture#

Let Copilot help you design more complex architectures:

// Create a microservices architecture with API Gateway, multiple App Services, and Redis cache
// Copilot suggestion:

resource apiManagement 'Microsoft.ApiManagement/service@2023-03-01-preview' = {
  name: '${projectName}-${environment}-apim'
  location: location
  sku: {
    name: 'Consumption'
    capacity: 0
  }
  properties: {
    publisherEmail: 'admin@${projectName}.com'
    publisherName: '${projectName} Lab'
  }
}

resource redisCache 'Microsoft.Cache/redis@2023-04-01' = {
  name: '${projectName}-${environment}-redis'
  location: location
  properties: {
    sku: {
      name: 'Basic'
      family: 'C'
      capacity: 0
    }
    enableNonSslPort: false
    minimumTlsVersion: '1.2'
  }
}

Security Best Practices#

Use Copilot to implement security patterns:

// Implement network security with NSGs and private endpoints
// Copilot will suggest comprehensive security configurations

resource networkSecurityGroup 'Microsoft.Network/networkSecurityGroups@2023-04-01' = {
  name: '${projectName}-${environment}-nsg'
  location: location
  properties: {
    securityRules: [
      {
        name: 'AllowHTTPS'
        properties: {
          priority: 1000
          access: 'Allow'
          direction: 'Inbound'
          destinationPortRange: '443'
          protocol: 'Tcp'
          sourceAddressPrefix: '*'
          sourcePortRange: '*'
          destinationAddressPrefix: '*'
        }
      }
    ]
  }
}

References and Further Learning#

Essential Documentation#

• GitHub Copilot Documentation
• Azure Bicep Documentation
• Terraform Azure Provider
• GitHub Actions for Azure

Learning Paths#

• Microsoft Learn: Infrastructure as Code
• Azure DevOps Learning Path
• GitHub Actions Certification

Community Resources#

• Azure DevOps Community
• Bicep Community
• r/AZURE Subreddit

Advanced Topics to Explore#

• GitOps with Flux: Implementing GitOps workflows in Azure
• Azure DevOps Integration: Connecting GitHub Actions with Azure DevOps
• Monitoring and Observability: Using Azure Monitor and Application Insights
• Security Scanning: Integrating security tools into your pipeline

Conclusion#

GitHub Copilot transforms the DevOps experience by making infrastructure automation more accessible and enjoyable. Through vibe coding, you can rapidly prototype, experiment, and iterate on your Azure infrastructure while learning best practices along the way.

Start small with the examples in this tutorial, then gradually expand your lab environment. The thing that made Copilot work here was staying iterative. Let curiosity drive the next prompt, and don’t be afraid to experiment.

Your Azure DevOps lab is now ready for exploration. Happy coding, and may your infrastructure be ever scalable and your deployments always green! 🚀

---

What’s your experience with GitHub Copilot for DevOps? Share your favorite Copilot-generated infrastructure patterns in the comments below!