DevOps help for Cloud Platform Engineers
  • Welcome!
  • Quick Start Guide
  • About Me
  • CV
  • 🧠DevOps & SRE Foundations
    • DevOps Overview
      • Engineering Fundamentals
      • Implementing DevOps Strategy
      • DevOps Readiness Assessment
      • Lifecycle Management
      • The 12 Factor App
      • Design for Self Healing
      • Incident Management Best Practices (2025)
    • SRE Fundamentals
      • Toil Reduction
      • System Simplicity
      • Real-world Scenarios
        • AWS VM Log Monitoring API
    • Agile Development
      • Team Agreements
        • Definition of Done
        • Definition of Ready
        • Team Manifesto
        • Working Agreement
    • Industry Scenarios
      • Finance and Banking
      • Public Sector (UK/EU)
      • Energy Sector Edge Computing
  • DevOps Practices
    • Platform Engineering
    • FinOps
    • Observability
      • Modern Practices
  • 🚀Modern DevOps Practices
    • Infrastructure Testing
    • Modern Development
    • Database DevOps
  • 🛠️Infrastructure as Code (IaC)
    • Terraform
      • Getting Started - Installation and initial setup [BEGINNER]
      • Cloud Integrations - Provider-specific implementations
        • Azure Scenarios
        • AWS Scenarios
        • GCP Scenarios
      • Testing and Validation - Ensuring infrastructure quality
        • Unit Testing
        • Integration Testing
        • End-to-End Testing
        • Terratest Guide
      • Best Practices - Production-ready implementation strategies
        • State Management
        • Security
        • Code Organization
        • Performance
      • Tools & Utilities - Enhancing the Terraform workflow
        • Terraform Docs
        • TFLint
        • Checkov
        • Terrascan
      • CI/CD Integration - Automating infrastructure deployment
        • GitHub Actions - GitHub-based automation workflows
        • Azure Pipelines - Azure DevOps integration
        • GitLab CI - GitLab-based deployment pipelines
    • Bicep
      • Getting Started - First steps with Bicep [BEGINNER]
      • Template Specs
      • Best Practices - Guidelines for effective Bicep implementations
      • Modules - Building reusable components [INTERMEDIATE]
      • Examples - Sample implementations for common scenarios
      • Advanced Features
      • CI/CD Integration - Automating Bicep deployments
        • GitHub Actions
        • Azure Pipelines
  • 💰Cost Management & FinOps
    • Cloud Cost Optimization
  • 🐳Containers & Orchestration
    • Containerization Overview
    • Docker
      • Dockerfile Best Practices
      • Docker Compose
    • Kubernetes
      • CLI Tools - Essential command-line utilities
        • Kubectl
        • Kubens
        • Kubectx
      • Core Concepts
      • Components
      • Best Practices
        • Pod Security
        • Security Monitoring
        • Resource Limits
      • Advanced Features - Beyond the basics [ADVANCED]
        • Service Mesh
        • Ingress Controllers
          • NGINX
          • Traefik
          • Kong
          • Gloo Edge
      • Troubleshooting - Diagnosing and resolving common issues
        • Pod Troubleshooting Commands
      • Enterprise Architecture
      • Health Management
      • Security & Compliance
      • Virtual Clusters
    • OpenShift
  • Service Mesh & Networking
    • Service Mesh Implementation
  • Architecture Patterns
    • Data Mesh
    • Multi-Cloud Networking
    • Disaster Recovery
    • Chaos Engineering
  • Edge Computing
    • Implementation Guide
    • Serverless Edge
    • IoT Edge Patterns
    • Real-Time Processing
    • Edge AI/ML
    • Security Hardening
    • Observability Patterns
    • Network Optimization
    • Storage Patterns
  • 🔄CI/CD & GitOps
    • CI/CD Overview
    • Continuous Integration
    • Continuous Delivery
      • Deployment Strategies
      • Secrets Management
      • Blue-Green Deployments
      • Deployment Metrics
      • Progressive Delivery
      • Release Management for DevOps/SRE (2025)
    • CI/CD Platforms - Tool selection and implementation
      • Azure DevOps
        • Pipelines
          • Stages
          • Jobs
          • Steps
          • Templates - Reusable pipeline components
          • Extends
          • Service Connections - External service authentication
          • Best Practices for 2025
          • Agents and Runners
          • Third-Party Integrations
          • Azure DevOps CLI
        • Boards & Work Items
      • GitHub Actions
      • GitLab
        • GitLab Runner
        • Real-life scenarios
        • Installation guides
        • Pros and Cons
        • Comparison with alternatives
    • GitOps
      • Modern GitOps Practices
      • GitOps Patterns for Multi-Cloud (2025)
      • Flux
        • Overview
        • Progressive Delivery
        • Use GitOps with Flux, GitHub and AKS
  • Source Control
    • Source Control Overview
    • Git Branching Strategies
    • Component Versioning
    • Kubernetes Manifest Versioning
    • GitLab
    • Creating a Fork
    • Naming Branches
    • Pull Requests
    • Integrating LLMs into Source Control Workflows
  • ☁️Cloud Platforms
    • Cloud Strategy
    • Azure
      • Best Practices
      • Landing Zones
      • Services
      • Monitoring
      • Administration Tools - Platform management interfaces
        • Azure PowerShell
        • Azure CLI
      • Tips & Tricks
    • AWS
      • Authentication
      • Best Practices
      • Tips & Tricks
    • Google Cloud
      • Services
    • Private Cloud
  • 🔐Security & Compliance
    • DevSecOps Overview
    • DevSecOps Pipeline Security
    • DevSecOps
      • Real-life Examples
      • Scanning & Protection - Automated security tooling
        • Dependency Scanning
        • Credential Scanning
        • Container Security Scanning
        • Static Code Analysis
          • Best Practices
          • Tool Integration Guide
          • Pipeline Configuration
      • CI/CD Security
      • Secrets Rotation
    • Supply Chain Security
      • SLSA Framework
      • Binary Authorization
      • Artifact Signing
    • Security Best Practices
      • Threat Modeling
      • Kubernetes Security
    • SecOps
    • Zero Trust Model
    • Cloud Compliance
      • ISO/IEC 27001:2022
      • ISO 22301:2019
      • PCI DSS
      • CSA STAR
    • Security Frameworks
    • SIEM and SOAR
  • Security Architecture
    • Zero Trust Implementation
      • Identity Management
      • Network Security
      • Access Control
  • 🔍Observability & Monitoring
    • Observability Fundamentals
    • Logging
    • Metrics
    • Tracing
    • Dashboards
    • SLOs and SLAs
    • Observability as Code
    • Pipeline Observability
  • 🧪Testing Strategies
    • Testing Overview
    • Modern Testing Approaches
    • End-to-End Testing
    • Unit Testing
    • Performance Testing
      • Load Testing
    • Fault Injection Testing
    • Integration Testing
    • Smoke Testing
  • 🤖AI Integration
    • AIops Overview
      • Workflow Automation
      • Predictive Analytics
      • Code Quality
  • 🧠AI & LLM Integration
    • Overview
    • Claude
      • Installation Guide
      • Project Guides
      • MCP Server Setup
      • LLM Comparison
    • Ollama
      • Installation Guide
      • Configuration
      • Models and Fine-tuning
      • DevOps Usage
      • Docker Setup
      • GPU Setup
      • Open WebUI
    • Copilot
      • Installation Guide
      • VS Code Integration
      • CLI Usage
    • Gemini
      • Installation Guides - Platform-specific setup
        • Linux Installation
        • WSL Installation
        • NixOS Installation
      • Gemini 2.5 Features
      • Roles and Agents
      • NotebookML Guide
      • Cloud Infrastructure Deployment
      • Summary
  • 💻Development Environment
    • Tools Overview
    • DevOps Tools
    • Operating Systems - Development platforms
      • NixOS
        • Installation
        • Nix Language Guide
        • DevEnv with Nix
        • Cloud Deployments
      • WSL2
        • Distributions
        • Terminal Setup
    • Editor Environments
    • CLI Tools
      • Azure CLI
      • PowerShell
      • Linux Commands
      • YAML Tools
  • 📚Programming Languages
    • Python
    • Go
    • JavaScript/TypeScript
    • Java
    • Rust
  • 📖Documentation Best Practices
    • Documentation Strategy
    • Project Documentation
    • Release Notes
    • Static Sites
    • Documentation Templates
    • Real-World Examples
  • 📋Reference Materials
    • Glossary
    • Tool Comparison
    • Recommended Reading
    • Troubleshooting Guide
  • Platform Engineering
    • Implementation Guide
  • FinOps
    • Implementation Guide
  • AIOps
    • LLMOps Guide
  • Development Setup
    • Development Setup
Powered by GitBook
On this page
  • Setup and Configuration
  • Installation
  • Configuration Options
  • Basic Usage
  • Code Suggestions
  • Using Comments to Guide Copilot
  • Multiple Suggestions
  • Advanced Features
  • GitHub Copilot Chat
  • Code Completion vs. Code Generation
  • Custom Settings for DevOps Tasks
  • Real-World DevOps Scenarios
  • Scenario 1: Creating Terraform Infrastructure
  • Scenario 2: Writing a GitHub Actions Workflow
  • Scenario 3: Creating a Kubernetes Deployment
  • Keyboard Shortcuts
  • Troubleshooting
  • Common Issues
  • Getting Support
Edit on GitHub
  1. AI & LLM Integration
  2. Copilot

VS Code Integration

This guide covers how to set up, configure, and effectively use GitHub Copilot in Visual Studio Code.

Setup and Configuration

Installation

  1. Open VS Code

  2. Navigate to Extensions (Ctrl+Shift+X)

  3. Search for "GitHub Copilot"

  4. Click "Install"

  5. After installation, click "Sign in" and authenticate with your GitHub account

Configuration Options

Access Copilot settings through:

  1. Open VS Code settings (Ctrl+,)

  2. Search for "Copilot"

  3. Adjust the following key settings:

Setting
Description
Recommended Value

Enable GitHub Copilot

Global toggle for the extension

✓ Enabled

Inlineable Suggestions

Show inline suggestions while typing

✓ Enabled

Filter Suggestions

Filter out suggestions matching certain patterns

Based on preference

Language Support

Enable/disable for specific languages

Enable for your primary languages

Basic Usage

Code Suggestions

GitHub Copilot provides real-time code suggestions as you type:

  1. Start typing code or add comments describing what you want to do

  2. Copilot will display ghosted text suggestions

  3. Accept suggestions with Tab or continue typing to reject

# Example: A function that calculates factorial
def factorial(n):  # Copilot will suggest the implementation

Using Comments to Guide Copilot

Use descriptive comments to get more accurate suggestions:

// Create a function that fetches user data from an API and returns a formatted object
async function fetchUserData(userId) {  // Copilot will suggest implementation

Multiple Suggestions

View alternative suggestions:

  1. Press Alt+] (Windows/Linux) or Option+] (Mac) to see the next suggestion

  2. Press Alt+[ (Windows/Linux) or Option+[ (Mac) to see the previous suggestion

  3. Press Alt+\ (Windows/Linux) or Option+\ (Mac) to open a separate panel with multiple suggestions

Advanced Features

GitHub Copilot Chat

Copilot Chat provides an interactive way to get coding assistance:

  1. Open the Copilot Chat panel (using the Copilot icon in the sidebar)

  2. Type questions or requests in natural language

  3. Use slash commands for specific actions:

Common slash commands:

  • /explain - Explain the selected code

  • /tests - Generate tests for the selected code

  • /fix - Suggest fixes for problems in the selected code

  • /optimize - Optimize the selected code

Code Completion vs. Code Generation

  • Code Completion: Small, contextual suggestions while typing

  • Code Generation: Creating entire functions or code blocks

For code generation:

  1. Write a detailed comment describing what you need

  2. Press Enter to create a new line

  3. Wait for Copilot to generate a suggestion

  4. Press Tab to accept or continue typing to reject

Custom Settings for DevOps Tasks

Optimize Copilot for DevOps work:

{
  "github.copilot.enable": {
    "*": true,
    "yaml": true,
    "plaintext": false,
    "markdown": true,
    "terraform": true,
    "dockerfile": true
  },
  "github.copilot.advanced": {
    "indentationMode": true,
    "listCount": 10
  }
}

Real-World DevOps Scenarios

Scenario 1: Creating Terraform Infrastructure

# Create an AWS EC2 instance with the following specifications:
# - t3.medium instance type
# - Amazon Linux 2 AMI
# - 20GB EBS volume
# - In a private subnet with a security group allowing SSH access

Scenario 2: Writing a GitHub Actions Workflow

# Create a GitHub Actions workflow that:
# - Runs on pull requests to main branch
# - Sets up a Python 3.9 environment
# - Installs dependencies from requirements.txt
# - Runs pytest with coverage
# - Uploads coverage report as an artifact

Scenario 3: Creating a Kubernetes Deployment

# Create a Kubernetes deployment for a web application with:
# - 3 replicas
# - Container using nginx:latest image
# - Resource limits: 256Mi RAM, 500m CPU
# - Health check on port 80
# - Service exposing port 80 with LoadBalancer

Keyboard Shortcuts

Action
Windows/Linux
macOS

Accept suggestion

Tab

Tab

Dismiss suggestion

Esc

Esc

Show next suggestion

Alt+]

Option+]

Show previous suggestion

Alt+[

Option+[

Open Copilot panel

Alt+\

Option+\

Open Copilot Chat

Ctrl+Shift+I

Cmd+Shift+I

Generate Docs

Alt+Shift+D

Option+Shift+D

Troubleshooting

Common Issues

  1. No suggestions appearing

    • Check if Copilot is enabled for the current language

    • Try restarting VS Code

    • Check your internet connection

  2. Poor quality suggestions

    • Improve your comments with more detail

    • Add more context to your code

    • Try different ways of describing what you want

  3. High latency

    • Check your internet connection

    • Close unnecessary extensions

    • Reduce the size of the file you're working on

Getting Support

PreviousInstallation GuideNextCLI Usage

Last updated 2 days ago

Visit

Check the

Join the

🧠
GitHub Copilot Support
VS Code Marketplace
GitHub Community Forum