Learning Path Navigation
- 📚 Course Home: AZD For Beginners
- 📖 Start Learning: Chapter 1: Foundation & Quick Start
- 🎯 Progress Tracking: Course Completion
This comprehensive study guide provides structured learning objectives, key concepts, practice exercises, and assessment materials to help you master Azure Developer CLI (azd). Use this guide to track your progress and ensure you've covered all essential topics.
By completing this study guide, you will:
- Master all fundamental and advanced concepts of Azure Developer CLI
- Develop practical skills in deploying and managing Azure applications
- Build confidence in troubleshooting and optimizing deployments
- Understand production-ready deployment practices and security considerations
After completing all sections of this study guide, you will be able to:
- Design, deploy, and manage complete application architectures using azd
- Implement comprehensive monitoring, security, and cost optimization strategies
- Troubleshoot complex deployment issues independently
- Create custom templates and contribute to the azd community
Duration: 30-45 minutes | Complexity: ⭐
- Understand Azure Developer CLI core concepts and terminology
- Successfully install and configure AZD on your development platform
- Deploy your first application using an existing template
- Navigate the AZD command-line interface effectively
- AZD project structure and components (azure.yaml, infra/, src/)
- Template-based deployment workflows
- Environment configuration basics
- Resource group and subscription management
- Installation Verification: Install AZD and verify with
azd version - First Deployment: Deploy todo-nodejs-mongo template successfully
- Environment Setup: Configure your first environment variables
- Resource Exploration: Navigate deployed resources in Azure Portal
- What are the core components of an AZD project?
- How do you initialize a new project from a template?
- What is the difference between
azd upandazd deploy? - How do you manage multiple environments with AZD?
Duration: 1-2 hours | Complexity: ⭐⭐
- Integrate Microsoft Foundry services with AZD workflows
- Deploy and configure AI-powered applications
- Understand RAG (Retrieval-Augmented Generation) implementation patterns
- Manage AI model deployments and scaling
- Microsoft Foundry Models service integration and API management
- AI Search configuration and vector indexing
- Model deployment strategies and capacity planning
- AI application monitoring and performance optimization
- AI Chat Deployment: Deploy azure-search-openai-demo template
- RAG Implementation: Configure document indexing and retrieval
- Model Configuration: Set up multiple AI models with different purposes
- AI Monitoring: Implement Application Insights for AI workloads
- How do you configure Microsoft Foundry Models services in an AZD template?
- What are the key components of a RAG architecture?
- How do you manage AI model capacity and scaling?
- What monitoring metrics are important for AI applications?
Duration: 45-60 minutes | Complexity: ⭐⭐
- Master environment configuration and management strategies
- Implement secure authentication patterns and managed identity
- Organize resources with proper naming conventions
- Configure multi-environment deployments (dev, staging, prod)
- Environment hierarchy and configuration precedence
- Managed identity and service principal authentication
- Key Vault integration for secrets management
- Environment-specific parameter management
- Multi-Environment Setup: Configure dev, staging, and prod environments
- Security Configuration: Implement managed identity authentication
- Secrets Management: Integrate Azure Key Vault for sensitive data
- Parameter Management: Create environment-specific configurations
- How do you configure different environments with AZD?
- What are the benefits of using managed identity over service principals?
- How do you securely manage application secrets?
- What is the configuration hierarchy in AZD?
Duration: 1-1.5 hours | Complexity: ⭐⭐⭐
-
Create and customize Bicep infrastructure templates
-
Implement advanced deployment patterns and workflows
-
Understand resource provisioning strategies
-
Design scalable multi-service architectures
-
Deploy containerized applications using Azure Container Apps and AZD
- Bicep template structure and best practices
- Resource dependencies and deployment ordering
- Parameter files and template modularity
- Custom hooks and deployment automation
- Container app deployment patterns (quick start, production, microservices)
- Custom Template Creation: Build a multi-service application template
- Bicep Mastery: Create modular, reusable infrastructure components
- Deployment Automation: Implement pre/post deployment hooks
- Architecture Design: Deploy complex microservices architecture
- Container App Deployment: Deploy the Simple Flask API and Microservices Architecture examples using AZD
- How do you create custom Bicep templates for AZD?
- What are the best practices for organizing infrastructure code?
- How do you handle resource dependencies in templates?
- What deployment patterns support zero-downtime updates?
Duration: 2-3 hours | Complexity: ⭐⭐⭐⭐
- Design and implement multi-agent AI architectures
- Orchestrate agent coordination and communication
- Deploy production-ready AI solutions with monitoring
- Understand agent specialization and workflow patterns
- Integrate containerized microservices as part of multi-agent solutions
- Multi-agent architecture patterns and design principles
- Agent communication protocols and data flow
- Load balancing and scaling strategies for AI agents
- Production monitoring for multi-agent systems
- Service-to-service communication in containerized environments
- Retail Solution Deployment: Deploy the complete multi-agent retail scenario
- Agent Customization: Modify Customer and Inventory agent behaviors
- Architecture Scaling: Implement load balancing and auto-scaling
- Production Monitoring: Set up comprehensive monitoring and alerting
- Microservices Integration: Extend the Microservices Architecture example to support agent-based workflows
- How do you design effective multi-agent communication patterns?
- What are the key considerations for scaling AI agent workloads?
- How do you monitor and debug multi-agent AI systems?
- What production patterns ensure reliability for AI agents?
Duration: 1 hour | Complexity: ⭐⭐
- Perform comprehensive capacity planning and resource validation
- Select optimal Azure SKUs for cost-effectiveness
- Implement automated pre-flight checks and validation
- Plan deployments with cost optimization strategies
- Azure resource quotas and capacity limitations
- SKU selection criteria and cost optimization
- Automated validation scripts and testing
- Deployment planning and risk assessment
- Capacity Analysis: Analyze resource requirements for your applications
- SKU Optimization: Compare and select cost-effective service tiers
- Validation Automation: Implement pre-deployment check scripts
- Cost Planning: Create deployment cost estimates and budgets
- How do you validate Azure capacity before deployment?
- What factors influence SKU selection decisions?
- How do you automate pre-deployment validation?
- What strategies help optimize deployment costs?
Duration: 1-1.5 hours | Complexity: ⭐⭐
- Develop systematic debugging approaches for AZD deployments
- Resolve common deployment and configuration issues
- Debug AI-specific problems and performance issues
- Implement monitoring and alerting for proactive issue detection
- Diagnostic techniques and logging strategies
- Common failure patterns and their solutions
- Performance monitoring and optimization
- Incident response and recovery procedures
- Diagnostic Skills: Practice with intentionally broken deployments
- Log Analysis: Use Azure Monitor and Application Insights effectively
- Performance Tuning: Optimize slow-performing applications
- Recovery Procedures: Implement backup and disaster recovery
- What are the most common AZD deployment failures?
- How do you debug authentication and permission issues?
- What monitoring strategies help prevent production issues?
- How do you optimize application performance in Azure?
Duration: 2-3 hours | Complexity: ⭐⭐⭐⭐
- Implement enterprise-grade deployment strategies
- Design security patterns and compliance frameworks
- Establish monitoring, governance, and cost management
- Create scalable CI/CD pipelines with AZD integration
- Apply best practices for production container app deployments (security, monitoring, cost, CI/CD)
- Enterprise security and compliance requirements
- Governance frameworks and policy implementation
- Advanced monitoring and cost management
- CI/CD integration and automated deployment pipelines
- Blue-green and canary deployment strategies for containerized workloads
- Enterprise Security: Implement comprehensive security patterns
- Governance Framework: Set up Azure Policy and resource management
- Advanced Monitoring: Create dashboards and automated alerting
- CI/CD Integration: Build automated deployment pipelines
- Production Container Apps: Apply security, monitoring, and cost optimization to the Microservices Architecture example
- How do you implement enterprise security in AZD deployments?
- What governance patterns ensure compliance and cost control?
- How do you design scalable monitoring for production systems?
- What CI/CD patterns work best with AZD workflows?
- Understand Azure Developer CLI fundamentals and core concepts
- Successfully install and configure azd on your development environment
- Complete your first deployment using an existing template
- Navigate the azd project structure and understand key components
- Templates, environments, and services
- azure.yaml configuration structure
- Basic azd commands (init, up, down, deploy)
- Infrastructure as Code principles
- Azure authentication and authorization
Exercise 1.1: Installation and Setup
# Complete these tasks:
1. Install azd using your preferred method
2. Install Azure CLI and authenticate
3. Verify installation with: azd version
4. Test connectivity with: azd auth login
5. Explore available templates: azd template listExercise 1.2: First Deployment
# Deploy a simple web application:
1. Initialize project: azd init --template todo-nodejs-mongo
2. Review project structure and configuration files
3. Deploy to Azure: azd up
4. Test the deployed application
5. Clean up resources: azd downExercise 1.3: Project Structure Analysis
Analyze the following components:
1. azure.yaml - service definitions and hooks
2. infra/ directory - Bicep templates and modules
3. src/ directory - application source code
4. .azure/ directory - environment configurations
- What are the three core concepts of azd architecture?
- What is the purpose of the azure.yaml file?
- How do environments help manage different deployment targets?
- What authentication methods can be used with azd?
- What happens when you run
azd upfor the first time?
# Create and configure multiple environments:
1. Create development environment: azd env new development
2. Create staging environment: azd env new staging
3. Create production environment: azd env new production
4. Configure different settings for each environment
5. Deploy the same application to different environmentsExercise 2.2: Advanced Configuration
# Modify azure.yaml to include:
1. Multiple services with different configurations
2. Pre and post deployment hooks
3. Environment-specific parameters
4. Custom resource naming patternsExercise 2.3: Security Configuration
# Implement security best practices:
1. Configure managed identity for service authentication
2. Set up Azure Key Vault for secrets management
3. Implement least-privilege access controls
4. Enable HTTPS and secure communication protocols- How does azd handle environment variable precedence?
- What are deployment hooks and when should you use them?
- How do you configure different SKUs for different environments?
- What are the security implications of different authentication methods?
- How do you manage secrets and sensitive configuration data?
- Master deployment workflows and best practices
- Understand Infrastructure as Code with Bicep templates
- Implement complex multi-service architectures
- Optimize deployment performance and reliability
- Bicep template structure and modules
- Resource dependencies and ordering
- Deployment strategies (blue-green, rolling updates)
- Multi-region deployments
- Database migrations and data management
Exercise 3.1: Custom Infrastructure
// Create custom Bicep templates for:
1. Web application with custom domain and SSL
2. Database with backup and high availability
3. Storage account with access policies
4. Monitoring and logging configuration
5. Network security groups and virtual networksExercise 3.2: Multi-Service Application
# Deploy a microservices architecture:
1. Frontend web application
2. Backend API service
3. Database service
4. Message queue service
5. Background worker serviceExercise 3.3: Database Integration
# Implement database deployment patterns:
1. Deploy PostgreSQL with connection pooling
2. Implement schema migrations
3. Configure backup and recovery procedures
4. Set up read replicas for performance
5. Implement data seeding for different environments- What are the advantages of using Bicep over ARM templates?
- How do you handle database migrations in azd deployments?
- What strategies exist for zero-downtime deployments?
- How do you manage dependencies between services?
- What are the considerations for multi-region deployments?
- Implement comprehensive pre-deployment checks
- Master capacity planning and resource validation
- Understand SKU selection and cost optimization
- Build automated validation pipelines
- Azure resource quotas and limits
- SKU selection criteria and cost implications
- Automated validation scripts and tools
- Capacity planning methodologies
- Performance testing and optimization
Exercise 4.1: Capacity Planning
# Implement capacity validation:
1. Create scripts to check Azure quotas
2. Validate service availability in target regions
3. Estimate resource costs for different SKUs
4. Plan for scaling and growth requirements
5. Document capacity requirements for each environmentExercise 4.2: Pre-flight Validation
# Build comprehensive validation pipeline:
1. Authentication and permissions validation
2. Template syntax and parameter validation
3. Resource naming and availability checks
4. Network connectivity and security validation
5. Cost estimation and budget verificationExercise 4.3: SKU Optimization
# Optimize service configurations:
1. Compare performance characteristics of different SKUs
2. Implement cost-effective development configurations
3. Design high-performance production configurations
4. Create monitoring dashboards for resource utilization
5. Set up auto-scaling policies- What factors should influence SKU selection decisions?
- How do you validate Azure resource availability before deployment?
- What are the key components of a pre-flight check system?
- How do you estimate and control deployment costs?
- What monitoring is essential for capacity planning?
- Master systematic troubleshooting methodologies
- Develop expertise in debugging complex deployment issues
- Implement comprehensive monitoring and alerting
- Build incident response and recovery procedures
- Common deployment failure patterns
- Log analysis and correlation techniques
- Performance monitoring and optimization
- Security incident detection and response
- Disaster recovery and business continuity
Exercise 5.1: Troubleshooting Scenarios
# Practice resolving common issues:
1. Authentication and authorization failures
2. Resource provisioning conflicts
3. Application startup and runtime errors
4. Network connectivity problems
5. Performance and scaling issuesExercise 5.2: Monitoring Implementation
# Set up comprehensive monitoring:
1. Application performance monitoring with Application Insights
2. Infrastructure monitoring with Azure Monitor
3. Custom dashboards and alerting rules
4. Log aggregation and analysis
5. Health check endpoints and automated testingExercise 5.3: Incident Response
# Build incident response procedures:
1. Create runbooks for common problems
2. Implement automated recovery procedures
3. Set up notification and escalation workflows
4. Practice disaster recovery scenarios
5. Document lessons learned and improvements- What is the systematic approach to troubleshooting azd deployments?
- How do you correlate logs across multiple services and resources?
- What monitoring metrics are most critical for early problem detection?
- How do you implement effective disaster recovery procedures?
- What are the key components of an incident response plan?
- Implement enterprise-grade deployment patterns
- Master CI/CD integration and automation
- Develop custom templates and contribute to the community
- Understand advanced security and compliance requirements
- CI/CD pipeline integration patterns
- Custom template development and distribution
- Enterprise governance and compliance
- Advanced networking and security configurations
- Performance optimization and cost management
Exercise 6.1: CI/CD Integration
# Implement automated deployment pipelines:
1. GitHub Actions workflow for azd deployments
2. Azure DevOps pipeline integration
3. Multi-stage deployment with approvals
4. Automated testing and quality gates
5. Security scanning and compliance checksExercise 6.2: Custom Template Development
# Create and publish custom templates:
1. Design template for your organization's architecture
2. Implement parameterization and customization options
3. Add comprehensive documentation and examples
4. Test template across different environments
5. Publish and maintain template in template galleryExercise 6.3: Enterprise Implementation
# Implement enterprise-grade features:
1. Multi-tenant architecture with proper isolation
2. Centralized logging and monitoring
3. Compliance and governance controls
4. Cost allocation and chargeback mechanisms
5. Disaster recovery and business continuity- How do you integrate azd into existing CI/CD workflows?
- What are the key considerations for custom template development?
- How do you implement governance and compliance in azd deployments?
- What are the best practices for enterprise-scale deployments?
- How do you contribute effectively to the azd community?
Complexity: Beginner
Duration: 1-2 weeks
Build and deploy a personal portfolio website using:
- Static website hosting on Azure Storage
- Custom domain configuration
- CDN integration for global performance
- Automated deployment pipeline
Deliverables:
- Working website deployed on Azure
- Custom azd template for portfolio deployments
- Documentation of deployment process
- Cost analysis and optimization recommendations
Complexity: Intermediate
Duration: 2-3 weeks
Create a full-stack task management application with:
- React frontend deployed to App Service
- Node.js API backend with authentication
- PostgreSQL database with migrations
- Application Insights monitoring
Deliverables:
- Complete application with user authentication
- Database schema and migration scripts
- Monitoring dashboards and alerting rules
- Multi-environment deployment configuration
Complexity: Advanced
Duration: 4-6 weeks
Design and implement a microservices-based e-commerce platform:
- Multiple API services (catalog, orders, payments, users)
- Message queue integration with Service Bus
- Redis cache for performance optimization
- Comprehensive logging and monitoring
Reference Example: See Microservices Architecture for a production-ready template and deployment guide
Deliverables:
- Complete microservices architecture
- Inter-service communication patterns
- Performance testing and optimization
- Production-ready security implementation
Complete these assessments after each module:
Module 1 Assessment: Basic concepts and installation
- Multiple choice questions on core concepts
- Practical installation and configuration tasks
- Simple deployment exercise
Module 2 Assessment: Configuration and environments
- Environment management scenarios
- Configuration troubleshooting exercises
- Security configuration implementation
Module 3 Assessment: Deployment and provisioning
- Infrastructure design challenges
- Multi-service deployment scenarios
- Performance optimization exercises
Module 4 Assessment: Pre-deployment validation
- Capacity planning case studies
- Cost optimization scenarios
- Validation pipeline implementation
Module 5 Assessment: Troubleshooting and debugging
- Problem diagnosis exercises
- Monitoring implementation tasks
- Incident response simulations
Module 6 Assessment: Advanced topics
- CI/CD pipeline design
- Custom template development
- Enterprise architecture scenarios
Design and implement a complete solution that demonstrates mastery of all concepts:
Requirements:
- Multi-tier application architecture
- Multiple deployment environments
- Comprehensive monitoring and alerting
- Security and compliance implementation
- Cost optimization and performance tuning
- Complete documentation and runbooks
Evaluation Criteria:
- Technical implementation quality
- Documentation completeness
- Security and best practices adherence
- Performance and cost optimization
- Troubleshooting and monitoring effectiveness
- Weeks 1-2: Modules 1-2 (Getting Started, Configuration)
- Weeks 3-4: Modules 3-4 (Deployment, Pre-deployment)
- Weeks 5-6: Modules 5-6 (Troubleshooting, Advanced Topics)
- Weeks 7-8: Practical Projects and Final Assessment
- Weeks 1-4: Module 1 (Getting Started)
- Weeks 5-7: Module 2 (Configuration and Environments)
- Weeks 8-10: Module 3 (Deployment and Provisioning)
- Weeks 11-12: Module 4 (Pre-deployment Validation)
- Weeks 13-14: Module 5 (Troubleshooting and Debugging)
- Weeks 15-16: Module 6 (Advanced Topics and Assessment)
Track your progress through each chapter with these measurable outcomes:
- Installation Complete: AZD installed and verified on your platform
- First Deployment: Successfully deployed todo-nodejs-mongo template
- Environment Setup: Configured first environment variables
- Resource Navigation: Explored deployed resources in Azure Portal
- Command Mastery: Comfortable with basic AZD commands
- AI Template Deployment: Deployed azure-search-openai-demo successfully
- RAG Implementation: Configured document indexing and retrieval
- Model Configuration: Set up multiple AI models with different purposes
- AI Monitoring: Implemented Application Insights for AI workloads
- Performance Optimization: Tuned AI application performance
- Multi-Environment Setup: Configured dev, staging, and prod environments
- Security Implementation: Set up managed identity authentication
- Secrets Management: Integrated Azure Key Vault for sensitive data
- Parameter Management: Created environment-specific configurations
- Authentication Mastery: Implemented secure access patterns
- Custom Template Creation: Built a multi-service application template
- Bicep Mastery: Created modular, reusable infrastructure components
- Deployment Automation: Implemented pre/post deployment hooks
- Architecture Design: Deployed complex microservices architecture
- Template Optimization: Optimized templates for performance and cost
- Retail Solution Deployment: Deployed complete multi-agent retail scenario
- Agent Customization: Modified Customer and Inventory agent behaviors
- Architecture Scaling: Implemented load balancing and auto-scaling
- Production Monitoring: Set up comprehensive monitoring and alerting
- Performance Tuning: Optimized multi-agent system performance
- Capacity Analysis: Analyzed resource requirements for applications
- SKU Optimization: Selected cost-effective service tiers
- Validation Automation: Implemented pre-deployment check scripts
- Cost Planning: Created deployment cost estimates and budgets
- Risk Assessment: Identified and mitigated deployment risks
- Diagnostic Skills: Successfully debugged intentionally broken deployments
- Log Analysis: Used Azure Monitor and Application Insights effectively
- Performance Tuning: Optimized slow-performing applications
- Recovery Procedures: Implemented backup and disaster recovery
- Monitoring Setup: Created proactive monitoring and alerting
- Enterprise Security: Implemented comprehensive security patterns
- Governance Framework: Set up Azure Policy and resource management
- Advanced Monitoring: Created dashboards and automated alerting
- CI/CD Integration: Built automated deployment pipelines
- Compliance Implementation: Met enterprise compliance requirements
- Milestone: Deploy first AI application using AZD
- Validation: Working application accessible via public URL
- Skills: Basic AZD workflows and AI service integration
- Milestone: Multi-environment deployment with secure authentication
- Validation: Same application deployed to dev/staging/prod
- Skills: Environment management and security implementation
- Milestone: Custom template for complex multi-service application
- Validation: Reusable template deployed by another team member
- Skills: Bicep mastery and infrastructure automation
- Milestone: Production-ready multi-agent AI solution
- Validation: System handling real-world load with monitoring
- Skills: Multi-agent orchestration and performance optimization
- Milestone: Enterprise-grade deployment with full compliance
- Validation: Passes security review and cost optimization audit
- Skills: Governance, monitoring, and CI/CD integration
- Practical Deployments: Working applications for each chapter
- Code Reviews: Template and configuration quality assessment
- Problem Solving: Troubleshooting scenarios and solutions
- Peer Teaching: Explain concepts to other learners
- Community Contribution: Share templates or improvements
- Portfolio Projects: 8 production-ready deployments
- Technical Skills: Industry-standard AZD and AI deployment expertise
- Problem-Solving Abilities: Independent troubleshooting and optimization
- Community Recognition: Active participation in Azure developer community
- Career Advancement: Skills directly applicable to cloud and AI roles
- Deployment Success Rate: >95% successful deployments
- Troubleshooting Time: <30 minutes for common issues
- Performance Optimization: Demonstrable improvements in cost and performance
- Security Compliance: All deployments meet enterprise security standards
- Knowledge Transfer: Ability to mentor other developers
- Azure Updates: Follow Azure Developer CLI release notes
- Community Events: Participate in Azure and AI developer events
- Documentation: Contribute to community documentation and examples
- Feedback Loop: Provide feedback on course content and Azure services
- Professional Network: Connect with Azure and AI experts
- Speaking Opportunities: Present learnings at conferences or meetups
- Open Source Contribution: Contribute to AZD templates and tools
- Mentorship: Guide other developers in their AZD learning journey
Chapter Navigation:
- 📚 Course Home: AZD For Beginners
- 📖 Start Learning: Chapter 1: Foundation & Quick Start
- 🎯 Progress Tracking: Track your advancement through the comprehensive 8-chapter learning system
- 🤝 Community: Azure Discord for support and discussion
Study Progress Tracking: Use this structured guide to master Azure Developer CLI through progressive, practical learning with measurable outcomes and professional development benefits.