Azure DevOps

chevron-rightMust read definition before interviewhashtag

Azure DevOps is a complete DevOps platform by Microsoft that supports planning, development, CI/CD, testing, and monitoring.

Azure Pipeline

Git

Git cherry-pick is used to apply a specific commit from one branch to another branch without merging the entire branch. used when Hotfix needed in production.

GitOps is a deployment model where Git is the single source of truth for infrastructure and application deployments.

git fetch downloads changes from the remote repository but does NOT apply them to your local branch. git merge combines another branch into your current branch and creates a merge commit. git pull is a shortcut for git fetch + git merge.

Conflict A merge conflict happens when Git cannot automatically merge changes because someone has updated the same lines of a file were modified differently in two branches occurs when: Two people edit the same line in a file .One deletes a file while another modifies it Rebase or cherry-pick conflicts

check conflicted files git status Open the conflicted file

Resolve the conflict manually Decide what to keep- correct code

Accept current branch git checkout --ours app.js Accept incoming branch git checkout --theirs app.js

How to Avoid Merge Conflicts (Best Practices)

Pull latest changes frequently

Keep feature branches short-lived

Use git pull --rebase

Avoid committing large files

Communicate before big changes

SonarQube is a static code analysis tool used to detect code quality issues, bugs, vulnerabilities, and security hotspots.

SonarQube ensures code quality and security by enforcing quality gates during CI/CD

how u design pipeline for multiple stages which branching strtergies ur using right now what is gitops what is blue green deployment how u integrates/handles secrets in pipleines tell me all cicd stages how u connect multiple target for deployment in azure devops

how to rollback

what is private endpoint and to use in azure how u connect db to azure app services

sonarqube

failed scenario what will u do if quality gate fail how u will skip some rule

what are the default rule in sonar

chevron-rightQAhashtag

Got it — I’ll frame this interview-ready, concise but strong (not textbook, but practical DevOps/SRE level answers). You can literally speak this.

I’ll structure it Q → Answer style 👇


✅ Interview-Ready Answers

🔹 How do you design CI/CD pipeline for multiple stages?

Answer:

I design pipelines using environment-based stages with clear separation of responsibilities. Typical flow:

1️⃣ Source Stage

  • Trigger on PR / merge

  • Branch policy validation

2️⃣ Build Stage

  • Compile/package

  • Unit tests

  • Static code scan

3️⃣ Artifact Stage

  • Version artifacts

  • Push to registry (Docker/Artifact feed)

4️⃣ Deploy Stages

  • Dev → QA → Staging → Production

  • Use approvals & gates between environments

  • Infra validation before deploy

5️⃣ Post Deploy

  • Smoke tests

  • Monitoring hooks

  • Rollback readiness

Key design principles

  • Reusable YAML templates

  • Parameterized stages

  • Environment approvals

  • Parallel jobs where possible

  • Secrets externalized

👉 I typically implement this in Azure DevOps/GitHub Actions/Jenkins using multi-stage YAML pipelines.


🔹 Which branching strategy are you using?

Answer:

Depends on team size, but commonly:

✔️ GitFlow (structured teams)

  • main → production

  • develop → integration

  • feature/*

  • release/*

  • hotfix/*

✔️ Trunk-based (my preference lately)

  • Short-lived feature branches

  • Frequent merges to main

  • Heavy automation + feature flags

Why I prefer trunk-based

  • Faster delivery

  • Less merge conflicts

  • Better CI/CD flow


🔹 What is GitOps?

Answer:

GitOps is an operational model where Git is the single source of truth for infrastructure and application deployment.

Instead of pushing deployments manually:

  • Desired state stored in Git

  • Controller (ArgoCD/Flux) watches repo

  • Automatically syncs cluster state

Benefits

  • Versioned infra

  • Easy rollback

  • Auditability

  • Declarative deployment

I’ve used this with Kubernetes using ArgoCD.


🔹 What is Blue-Green Deployment?

Answer:

Deployment strategy using two environments:

  • Blue → current production

  • Green → new version

Steps:

  1. Deploy new version to Green

  2. Test

  3. Switch traffic

  4. Keep Blue for rollback

Benefits

  • Zero downtime

  • Instant rollback

Commonly implemented via:

  • Load balancer switch

  • DNS routing

  • Kubernetes service switch


🔹 How do you integrate/handle secrets in pipelines?

Answer:

I avoid storing secrets in repo or YAML.

Common methods:

  • Azure Key Vault integration

  • Pipeline secret variables

  • Kubernetes secrets

  • HashiCorp Vault

Best practices:

  • RBAC access

  • Secret rotation

  • Masking in logs

  • Least privilege

  • Inject at runtime only


🔹 Tell me all CI/CD stages

Answer:

Typical lifecycle:

1️⃣ Code Commit 2️⃣ Build 3️⃣ Unit Testing 4️⃣ Static Code Analysis 5️⃣ Artifact Packaging 6️⃣ Security Scan 7️⃣ Publish Artifact 8️⃣ Deploy to Dev 9️⃣ Integration Testing 🔟 Deploy to Staging 11️⃣ Performance Testing 12️⃣ Approval Gate 13️⃣ Production Deployment 14️⃣ Monitoring & Feedback


🔹 How do you connect multiple targets for deployment in Azure DevOps?

Answer:

Several ways:

  • Deployment Jobs with Environments

  • Service Connections (ARM/Kubernetes)

  • Variable groups per target

  • Matrix strategy for parallel deploy

Example:

  • Same pipeline deploys to multiple AKS clusters

  • Each using its own service connection

  • Parameterized YAML template


🔹 What is Private Endpoint in Azure?

Answer:

Private Endpoint allows Azure services to be accessed via:

✅ Private IP inside VNet ❌ Not exposed to public internet

Used for:

  • SQL

  • Storage

  • Key Vault

Benefits

  • Improved security

  • Reduced attack surface

  • Compliance


🔹 How do you connect DB to Azure App Service?

Answer:

Common methods:

Public Access

  • Connection string config

  • Firewall allow

Secure (Preferred)

  • Managed Identity

  • Private Endpoint

  • VNet Integration

App Service connects to DB via private network.


🔹 SonarQube

What is SonarQube?

Answer:

Code quality and security analysis platform that checks:

  • Bugs

  • Vulnerabilities

  • Code smells

  • Coverage

  • Duplication

Integrated into CI pipeline before build passes.


If Quality Gate fails — what do you do?

Answer:

Steps:

1️⃣ Review issues in dashboard 2️⃣ Fix critical/high issues 3️⃣ Re-run pipeline

If urgent:

  • Discuss with team

  • Evaluate risk

  • Temporary override (rare)

Never blindly ignore


How do you skip some rules?

Answer:

Options:

  • Mark issue as False Positive

  • Suppress in code comment

  • Custom Quality Profile

  • Disable rule in Sonar

Usually managed by tech lead.


What are default rules in Sonar?

Answer:

Depends on language but categories include:

  • Reliability (bugs)

  • Security vulnerabilities

  • Maintainability issues

  • Code duplication

  • Naming conventions

  • Complexity limits

  • Dead code detection

Each language has predefined Quality Profiles.


⭐ If interviewer asks — strong closing line

You can say:

"I focus on designing pipelines that are secure, scalable, and automated end-to-end — integrating quality checks, GitOps-based deployments, and safe release strategies like blue-green to ensure reliability."


If you want — I can take this one step further and do: ✅ Rapid-fire mock interview on these questions ✅ Deep dive answers (senior-level) ✅ Azure DevOps YAML example pipeline

Just tell me 👍

Got it — I’ll answer these in clean interview-ready wording so you can speak them confidently. I’ll keep them practical and not overly theoretical.


✅ Interview-Ready Answers

🔹 How do you avoid secrets printing in logs?

Answer:

I follow a few best practices to ensure secrets never appear in logs:

  • Store secrets in secure stores (Azure Key Vault, pipeline secret variables)

  • Mark variables as secret/masked

  • Avoid echo/print commands in scripts

  • Disable verbose/debug logging when handling sensitive data

  • Use runtime injection instead of hardcoding

  • Limit log access via RBAC

Key line

Secrets are injected only at runtime and masked automatically by the pipeline engine.


🔹 How do you handle secrets in Kubernetes?

Answer:

Typical approach:

  • Use Kubernetes Secrets

  • Encrypt secrets at rest

  • RBAC restrictions

  • Mount as env variables or volumes

Production Best Practice

  • External secret manager integration

    • Azure Key Vault CSI Driver

    • Vault

  • Rotate secrets

  • Avoid storing plaintext in Git

Short summary

I prefer external secret management integrated with Kubernetes to improve security and rotation.


🔹 How do ArgoCD and Image Updater connect to AKS?

Answer:

ArgoCD runs inside the AKS cluster and connects using Kubernetes API.

Flow:

1️⃣ ArgoCD watches Git repo 2️⃣ Detects changes 3️⃣ Syncs manifests to AKS

Image Updater:

  • Monitors container registry (ACR)

  • Updates image tags in Git

  • ArgoCD detects commit

  • Deploys automatically

Result

  • Fully GitOps-based deployment cycle


🔹 What are Deployment Slots?

Answer:

Deployment slots are separate runtime environments within Azure App Service.

Common slots:

  • Production

  • Staging

Benefits

  • Deploy without downtime

  • Test before go-live

  • Instant rollback via swap

Interview line

I use slots to validate deployments and perform zero-downtime releases.


🔹 How do you use parallel jobs in Azure Pipeline?

Answer:

I use parallel jobs to:

  • Run tests simultaneously

  • Build multiple services

  • Deploy to multiple regions/clusters

Techniques

  • Job matrix strategy

  • Multiple agents

  • Stage/job parallelization

Benefit

  • Reduces pipeline execution time significantly


🔹 How do you speed up deployment and reduce CI/CD time?

Answer:

Strategies I use:

CI Optimization

  • Dependency caching

  • Incremental builds

  • Parallel testing

  • Smaller Docker layers

CD Optimization

  • Reusable templates

  • Artifact promotion

  • Parallel deploy

  • Helm chart optimization

Infrastructure

  • Fast build agents

  • Auto-scaling runners

  • Remove redundant steps

Key mindset

Continuously monitor pipeline metrics and eliminate bottlenecks.


🔹 What are the biggest challenges you faced?

This is behavioral — answer strategically:

Example Strong Answer:

One major challenge was pipeline instability during Kubernetes scaling events that caused deployment failures. I investigated logs, identified resource contention on agents, optimized pipeline concurrency, and implemented retry logic. This improved reliability and reduced failure rates significantly.

OR (Alternative)

Managing secret sprawl across environments — I centralized secrets in Key Vault and automated injection, improving security and auditability.


⭐ Strong Closing Summary (Use if needed)

I focus on secure secret management, GitOps-driven deployments, optimizing pipeline performance through parallelization and caching, and addressing real-world reliability challenges through monitoring and automation.


If you want — next step (this would REALLY prepare you): I can simulate actual Azure DevOps technical round where I ask unpredictable follow-ups like a real interviewer. Just tell me 🙂

Got it — I’ll answer these in interview-ready tone (practical, not theory). You can speak these almost as-is 👇


✅ Interview-Ready Answers

🔹 What severity threshold did you set for Trivy scan failure, and what do you do when it fails?

Answer:

In my pipelines, I usually configure Trivy to fail the build on HIGH and CRITICAL vulnerabilities. Medium/Low are reported but don’t block delivery unless it’s a sensitive service.

When it fails:

1️⃣ Review scan report 2️⃣ Identify vulnerable dependency/image layer 3️⃣ Upgrade base image/package 4️⃣ Rebuild and rescan 5️⃣ If urgent release:

  • Risk discussion with security team

  • Temporary exception (documented)

Key principle

Security gates should protect production but remain practical for delivery speed.


🔹 How do you integrate AKS with Azure Pipelines?

Answer:

Typical steps:

1️⃣ Create Service Connection (Azure RM or Kubernetes) 2️⃣ Grant pipeline permissions 3️⃣ Use pipeline tasks:

  • Build image

  • Push to ACR

  • Deploy via Helm/kubectl

Deployment flow

  • CI builds container

  • Push to registry

  • CD deploys to AKS

Tools I’ve used

  • Helm charts

  • YAML deployment templates


🔹 How do you integrate App Services with Azure Pipelines?

Answer:

Integration is straightforward:

1️⃣ Create Azure Service Connection 2️⃣ Build artifact/package 3️⃣ Use App Service Deploy task

Supports:

  • Zip deploy

  • Container deploy

  • Slot deployment

Best Practice

  • Use deployment slots

  • Swap after validation


🔹 How do you troubleshoot, monitor, integrate DB, and debug App Services?

Answer:

Troubleshooting

  • App Service logs

  • Deployment logs

  • Failed request tracing

Monitoring

  • Azure Monitor

  • Application Insights

  • Metrics & alerts

DB Integration

  • Connection string config

  • Managed identity (preferred)

  • Private endpoint

Debugging

  • Live log streaming

  • Performance metrics

  • Dependency tracking


🔹 What environments do you have and how do you manage them?

Answer:

Typically:

  • Dev

  • QA/Test

  • Staging

  • Production

Management Approach

  • Azure DevOps Environments

  • Separate configs/variables

  • Approval gates

  • Isolated resources

  • Parameterized pipelines

Goal

Promote artifacts across environments — don’t rebuild.


🔹 How do you manage AKS and Azure resources?

Answer:

Infrastructure

  • Terraform/Bicep automation

  • Git version control

AKS

  • Helm deployments

  • Autoscaling tuning

  • Monitoring

  • RBAC/security

Resource Management

  • Tagging strategy

  • Cost monitoring

  • Policy enforcement


🔹 When do you collaborate with multiple teams?

Answer:

Daily collaboration happens during:

  • Pipeline failures with dev team

  • Release planning with QA

  • Security reviews

  • Infra design discussions

  • Incident response

Strong interview line:

DevOps is highly collaborative — my role often bridges development, security, and infrastructure teams to ensure smooth delivery.


⭐ If interviewer rapid-fires — One Compact Summary

You can conclude with:

I focus on secure pipelines using vulnerability gates, automated deployments to AKS and App Services, environment isolation, proactive monitoring, and strong cross-team collaboration to maintain reliable delivery.


👉 If you want next-level prep

I can now simulate actual panel-style grilling questions on Azure DevOps/AKS/App Services (this is usually what comes next). Just say 👍

Alright — I’ll answer these interview-ready, concise and practical (the way you should speak in an interview). I’ll clean up wording and structure.


✅ Interview Answers

🔹 What is the default threshold in SonarQube Quality Gate?

Answer:

SonarQube’s default “Sonar Way” quality gate typically checks:

  • No new bugs

  • No new vulnerabilities

  • Maintainability rating = A

  • Security rating = A

  • Coverage on new code ≥ 80%

  • Duplicated lines on new code ≤ 3%

👉 These can vary by version/language and are customizable.

Interview tip: Say:

The thresholds are configurable, and most organizations tune them based on project risk and maturity.


🔹 How do you perform rollback?

Answer:

Rollback strategy depends on deployment type:

Containers/Kubernetes

  • Roll back to previous image tag

  • kubectl rollout undo

  • Redeploy previous artifact

App Service

  • Swap deployment slots

  • Redeploy last successful build

Pipelines

  • Use stored artifacts/version history

Infra (IaC)

  • Revert Git commit

  • Reapply Terraform

Key principle

Always maintain versioned artifacts and immutable deployments to ensure safe rollback.


🔹 Blob Tier — Versioning — Access — Lifecycle (Azure Storage)

Answer:

Storage Tiers

  • Hot → frequent access

  • Cool → infrequent access

  • Archive → long-term storage

Versioning

  • Keeps previous blob versions

  • Protects against accidental overwrite/delete

Access Levels

  • Private

  • Blob public

  • Container public

  • SAS Tokens

Lifecycle Policies

Automates:

  • Tier transitions

  • Expiry/deletion

  • Cost optimization


🔹 How do you debug pipeline failure?

Answer:

General approach:

1️⃣ Check logs 2️⃣ Identify failing stage/task 3️⃣ Validate config/variables 4️⃣ Reproduce locally 5️⃣ Compare with last successful run 6️⃣ Fix & re-run


🔹 How do you debug CI failure?

Answer:

Focus areas:

  • Build errors

  • Dependency issues

  • Unit test failures

  • Static scan failures

  • Resource limits on agents

Steps:

  • Inspect logs

  • Validate build environment

  • Re-run tests locally

  • Check recent code changes


🔹 How do you debug CD failure?

Answer:

Typical checks:

  • Service connection permissions

  • Infrastructure availability

  • Deployment configuration

  • Secret access

  • Network connectivity

  • Target health

Tools used:

  • Azure logs

  • Kubernetes events

  • App Service logs


🔹 What does your day look like as an Azure DevOps Engineer?

Answer:

My day usually involves monitoring and maintaining CI/CD pipelines, resolving build or deployment issues, automating infrastructure provisioning, managing access and secrets, collaborating with development teams, supporting releases, and optimizing pipeline performance.

Also includes:

  • PR reviews

  • Cost/security improvements

  • Documentation


🔹 How do you integrate Key Vault in Azure Pipeline?

Answer:

Typical approach:

1️⃣ Create Service Connection 2️⃣ Grant pipeline access to Key Vault 3️⃣ Use Key Vault task or variable group 4️⃣ Secrets injected during runtime

Benefits:

  • No secrets in repo

  • Centralized management

  • RBAC controlled


🔹 How do you manage multiple environments in Azure DevOps?

Answer:

I use:

Environments Feature

  • Dev / Test / Prod separation

  • Approval gates

Variable Groups

  • Environment-specific configs

YAML Templates

  • Reusable pipeline logic

Service Connections

  • Separate credentials

Branch Strategy

  • Dev → Stage → Main

Best Practice

Parameterized pipelines deploying to different targets based on environment input.


⭐ Strong Closing Summary (Use this line)

If interviewer asks multiple questions quickly:

My focus is on building secure, repeatable CI/CD pipelines with proper quality gates, versioning, environment separation, and rollback strategies while ensuring efficient debugging and smooth multi-environment deployments.


If you want — next step (highly recommended before interview): I can simulate a real Azure DevOps interview round and grill you with follow-ups like a panel interviewer would. Just tell me 👍

chevron-rightroles and responsibilities brekdownhashtag

“What does your day-to-day look like as a Senior Azure DevOps Engineer?”

I’ll answer this as a senior Azure DevOps engineer, with realistic responsibilities and time split 👇


👨‍💻 Senior Azure DevOps Engineer – Day-to-Day Work

My day-to-day work is a balance between delivery, reliability, security, and enablement, not just writing pipelines.

⏱️ Typical Time Breakdown

1️⃣ CI/CD Pipelines & Release Engineering (25–30%)

  • Designing and maintaining Azure DevOps YAML pipelines

- writing yml designing stages

  • Improving build and deployment speed

  • dockerignore, gitignore, caching in dockerfile, multistage dockerfile, minimal base image

  • Handling multi-stage pipelines (Build → Test → Security → Deploy)

  • docker, sonarqube, snyk

  • Integration (vault, ACR, AKS, agent pool, snyk, sonar, alert)

  • Supporting blue-green / canary / rolling deployments

  • we areusing default one rolling updates

  • Troubleshooting failed pipelines and release issues

build failures,

👉 Goal: Fast, reliable, repeatable releases


2️⃣ Kubernetes & Platform Operations (20–25%)

  • Managing AKS clusters

run kubectl cmd check resources, patch resources, get

  • Helm chart creation and upgrades

  • Auto-scaling using HPA & Karpenter

  • Handling node upgrades, cluster scaling, and workloads

  • Working closely with dev teams on deployment patterns

  • debugging and troubleshooting

  • storage, vault, logging, network driver adds on setup

  • setting up logging (promtail-loki), tracing (otel-prom) and metric (node-expo -prom)

  • scaling workloads (HPA, Karpenter, cluster autoscaler)

  • Scheduling (affinity rule, node schedular)

  • Ingress, api gatewat, load balancer and services mgmt

  • avoiding downtime (PDB)

  • pckg mngmt (helm)

  • respurce quota (cpu, ram allocation)

  • deploying cluster (clickhouse, rabbitmq)

  • troubleshooting (node not ready, crashloopbackoff, oomkilled)

  • maintainance (cluster upgrades, migrating workloads)

  • backup (etcd)

  • gitops - argocd (kustomize-yml manifest, helm)

  • RBAC (service account, aws_auth)

👉 Goal: Stable, scalable Kubernetes platform


3️⃣ Infrastructure as Code – Terraform & Ansible (15–20%)

  • Using Ansible + Linux for configuration management and OS-level automation

  • os level docker deployments, upgrades, patching

  • Managing multiple environments (dev, stage, prod)

  • modularity (Writing and reviewing Terraform modules for Azure (VNets, AKS, ACR, Key Vault, IAM))

  • Ensuring IaC follows best practices and security standards (meta args, ifecycle hook, remote state, locking, modules. cicd, lint, approve gate)

  • Auditing, monitoring, logging

  • lifecycle mgmt (init, lint, validate, refresh, fmt, pln, apply, destroy)

  • branching startergies

👉 Goal: Consistent, auditable infrastructure


4️⃣ Security, Code Quality & Compliance (10–15%)

  • Integrating SonarQube for code quality checks

  • Using Snyk for dependency, container, and IaC vulnerability scanning

  • Managing secrets with Azure Key Vault / Vault

  • Implementing IAM, RBAC, network security, and policy checks

  • Shifting security left in CI/CD

  • alerting vulnerability and connect with dev

👉 Goal: Secure-by-default pipelines


5️⃣ Monitoring, Reliability & Incident Handling (10–15%)

  • Monitoring with Prometheus, Grafana, Azure Monitor

  • Responding to alerts and incidents

  • Root cause analysis (RCA)

  • Improving SLAs, SLOs, and reducing MTTR

  • Capacity planning and performance tuning

👉 Goal: High availability & SLA adherence


6️⃣ Automation, AI & DevOps Enablement (5–10%)

  • Building RAG-based internal DevOps assistants

  • Using Agentic AI workflows to:

    • Run operational tasks

    • Answer infra/pipeline questions

    • Assist in incident diagnostics

  • Creating internal docs, templates, and reusable modules

  • Mentoring junior DevOps engineers

👉 Goal: Reduce manual effort & improve team productivity


🎯 Interview-Friendly Summary Line (Use This)

“As a Senior Azure DevOps Engineer, my day is split between CI/CD, Kubernetes operations, IaC, security, and reliability, with a strong focus on automation, fast releases, SLA compliance, and enabling development teams to ship safely and faster.”


If you want, I can also:

  • Convert this into a 2-minute spoken answer

  • Map this directly to an Azure DevOps roadmap

  • Tailor it for manager / architect / lead DevOps interviews

  • Add real metrics (MTTR, deployment frequency, cost savings)

Just tell me 👍

chevron-rightsonar and snykhashtag

Yes — you can (and should) use SonarQube + Snyk together in an Azure DevOps pipeline, and they actually complement each other very well 👍 Below is a clear, DevOps-practical explanation with how and where to use each, plus a sample Azure Pipeline.


1️⃣ What each tool is best at

🔍 SonarQube

Best for code quality & security inside your source code.

Covers:

  • Bugs & code smells

  • Security hotspots

  • OWASP Top 10 issues

  • Vulnerabilities in application code

  • Code coverage & maintainability

  • Quality Gates (fail build if standards not met)

👉 Runs during build/compile stage


🛡️ Snyk

Best for dependency, container, and IaC security.

Covers:

  • Open-source dependency vulnerabilities

  • Container image vulnerabilities

  • Terraform / Kubernetes / Helm IaC scanning

  • License compliance

👉 Runs after build and before deploy


This gives you shift-left security + fast feedback.


3️⃣ Azure DevOps Pipeline – Example (YAML)

🔹 SonarQube Scan

✔ Fails pipeline if Quality Gate fails


🔹 Snyk Scan (Dependencies + IaC)


🔹 Snyk Container Scan (Optional)


🔹 Snyk IaC (Terraform / K8s / Helm)


4️⃣ Where this helps you as DevOps Engineer

Higher code quality (SonarQube) ✔ Zero vulnerable dependencies reaching prod (Snyk) ✔ Security gates in CI/CDStrong DevOps & security maturity (great for interviews)


5️⃣ Interview-ready one-liner

“We use SonarQube for code quality and SAST and Snyk for dependency, container, and IaC scanning, integrated into Azure DevOps pipelines with security gates before deployment.”


If you want, I can:

  • Customize this exactly for your Azure DevOps setup

  • Add approval gates

  • Show how to fail pipeline only on HIGH/CRITICAL

  • Add Slack / Teams alerts

Just tell me 👍

login to https://dev.azure.com/arrow-up-right via email id

switch to ur organization

https://learn.microsoft.com/en-us/azure/devops/pipelines/process/phases?view=azure-devops&tabs=yamlarrow-up-right

azure devops is separate portal folder dev.azure.com create project eg zapconecthub

azure repos go to repos and copy https url ssh or https

inside files u will see all the content like github

under pipeline we 3 option pipelines environments library

prerequiesites

create azure container registry

create resources group

here we can see some default yml as we selected template

it have triggers, resources, variables, stages

vairable for connecting to azure container registry

dockerregistryserviceconneting: "vhgvf"

agent vm can be selfhosted or microft hosted

vmimagename: ubuntu-latest

own agent

pool:

name: "azureagent"

Stages > stage > jobs > job > steps > task

stage like build, push image

create vm for same

add agent vm in agent pool

run cmd on vm to add as a agent

create PAT token to add in linux cmd

similar to github runner and run this as backurnd by adding as a service

install docker on agent server

add azure user to docker group

and logout and login server ans start agent service

Last updated