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
  • Overview
  • Installation
  • Prerequisites
  • Standard Installation
  • Verification
  • Core Commands
  • 1. gh copilot explain
  • 2. gh copilot suggest
  • 3. gh copilot what-the-shell (or wts)
  • Advanced Usage
  • Environment Variables
  • Creating Aliases
  • Integration with Shell History
  • Real-World DevOps Scenarios
  • Scenario 1: Kubernetes Troubleshooting
  • Scenario 2: Complex Log Analysis
  • Scenario 3: Infrastructure Deployment
  • Tips for Effective Use
  • Security Considerations
  • Troubleshooting
  • Common Issues
  • Getting Help
Edit on GitHub
  1. AI & LLM Integration
  2. Copilot

CLI Usage

This guide covers the GitHub Copilot Command Line Interface (CLI), a powerful tool that brings AI-assisted coding to your terminal.

Overview

GitHub Copilot CLI enhances your command line experience with:

  • Natural language explanations of shell commands

  • Command generation from natural language descriptions

  • Shell command transformations and improvements

  • Git operations assistance

Installation

Prerequisites

  • Node.js 16 or higher

  • npm or yarn

  • GitHub CLI (gh)

  • GitHub Copilot subscription

Standard Installation

# Install GitHub Copilot CLI
npm install -g @githubnext/github-copilot-cli

# Authenticate
gh auth login
gh copilot auth login

Verification

After installation, verify that the CLI works correctly:

gh copilot explain "ls -la | grep '^d'"

You should receive an explanation of the command, which lists directories in the current location.

Core Commands

GitHub Copilot CLI offers three primary commands:

1. gh copilot explain

Explains what a command does in natural language.

# Basic usage
gh copilot explain "find . -type f -name '*.js' -mtime -7"

# With alias
gh explain "docker ps --filter 'status=exited'"

Example output:

This command finds all JavaScript files (*.js) modified in the last 7 days in the current directory and its subdirectories.

2. gh copilot suggest

Generates shell commands from natural language descriptions.

# Basic usage
gh copilot suggest "create a tar archive of the logs directory"

# With alias
gh suggest "find all PNG files larger than 1MB"

Example output:

I'll help you create a tar archive of the logs directory.

$ tar -czvf logs.tar.gz logs/

This command creates a compressed tar archive named 'logs.tar.gz' containing the contents of the logs directory.

Would you like me to run this command? [Y/n]

3. gh copilot what-the-shell (or wts)

Transforms one command into another based on your needs.

# Basic usage
gh copilot what-the-shell "curl https://api.github.com/repos/cli/cli/releases/latest" --flags "--include rate limit info"

Example output:

I'll help transform your command to include rate limit info.

$ curl -I https://api.github.com/repos/cli/cli/releases/latest

This command performs a HEAD request to show only the headers, which will include rate limit information.

Would you like me to run this command? [Y/n]

Advanced Usage

Environment Variables

Customize Copilot CLI behavior with environment variables:

# Disable automatic command execution
export GITHUB_COPILOT_NO_AUTO_EXECUTE=1

# Change the model used by Copilot (expert users)
export GITHUB_COPILOT_MODEL=gpt-4

Creating Aliases

Set up aliases in your shell configuration file (~/.bashrc, ~/.zshrc, etc.):

# Shorter aliases for common commands
alias explain="gh copilot explain"
alias suggest="gh copilot suggest"
alias wts="gh copilot what-the-shell"

Integration with Shell History

Use Copilot CLI to improve previous commands:

# Get the last command from history and explain it
gh copilot explain "$(history | tail -n 1 | sed 's/^[0-9 ]*//')"

# Transform your last command
gh copilot what-the-shell "$(history | tail -n 1 | sed 's/^[0-9 ]*//')" --flags "make it verbose"

Real-World DevOps Scenarios

Scenario 1: Kubernetes Troubleshooting

# Get suggestions for troubleshooting a pod
gh suggest "how to check if a pod is stuck in pending state"

# Possible output:
# $ kubectl describe pod <pod-name> -n <namespace>

Scenario 2: Complex Log Analysis

# Get help creating a complex log analysis command
gh suggest "find errors in nginx logs from the last hour and count occurrences by IP address"

# Possible output:
# $ grep "ERROR" /var/log/nginx/error.log | grep -E "$(date -d '1 hour ago' +'%d/%b/%Y:%H')" | awk '{print $1}' | sort | uniq -c | sort -nr

Scenario 3: Infrastructure Deployment

# Get suggestions for AWS CLI commands
gh suggest "create an AWS EC2 instance with t3.micro type and Amazon Linux 2"

# Possible output:
# $ aws ec2 run-instances --image-id ami-0323c3dd2da7fb37d --instance-type t3.micro --key-name MyKeyPair --security-group-ids sg-903004f8 --count 1

Tips for Effective Use

  1. Be Specific: The more detailed your description, the more accurate the suggestions.

  2. Learn from Explanations: Use the explain command to learn unfamiliar commands.

  3. Iterate on Suggestions: If the initial suggestion isn't quite right, refine your request.

  4. Combine with Traditional Tools: Use Copilot CLI alongside traditional command line tools like man, tldr, and --help.

  5. Review Before Executing: Always review suggested commands before running them, especially for destructive operations.

Security Considerations

  1. Command Review: Always review suggested commands before execution.

  2. Sensitive Information: Avoid including sensitive information in your requests.

  3. System Access: Remember that executed commands have the same permissions as your current user.

  4. Network Connectivity: All queries are sent to GitHub's servers, requiring internet connectivity.

Troubleshooting

Common Issues

  1. Authentication Problems

    • Run gh auth status to check GitHub CLI authentication

    • Try re-authenticating with gh auth login followed by gh copilot auth login

  2. Command Not Found

    • Ensure Node.js is installed and in your PATH

    • Verify installation with npm list -g @githubnext/github-copilot-cli

  3. Poor Suggestions

    • Be more specific in your requests

    • Try rephrasing the request

    • Ensure you're using English for best results

  4. API Rate Limits

    • If you encounter rate limits, wait before making more requests

    • Consider upgrading your GitHub plan for higher limits

Getting Help

  • Run gh copilot --help for command-line help

PreviousVS Code IntegrationNextGemini

Last updated 2 days ago

Visit

Check the

🧠
GitHub Copilot CLI Repository
GitHub Community Forum