Let’s make it work for you
Overview
This course teaches developers how to create, monitor, and troubleshoot AI solutions on Microsoft Azure. Participants learn how to implement Azure compute and containerisation patterns to host applications, build serverless APIs using Azure Functions, and integrate services through event-driven and message-based architectures.
The course also explores Azure data services that support modern AI workloads. Learners work with services including Azure Cosmos DB for NoSQL, Azure Database for PostgreSQL with pgvector, and Azure Managed Redis to implement data storage, caching, streaming, and vector search capabilities.
Throughout the course, developers build secure, scalable, and observable AI-driven applications by connecting services, orchestrating AI workflows, and implementing monitoring and operational best practices across the Azure platform.
Prerequisites
Participants should have:
- Basic experience developing applications using Python, .NET, JavaScript, or another general purpose programming language
- A foundational understanding of cloud computing concepts such as compute, storage, and networking
- Awareness of containerisation principles such as Docker images, registries, and container lifecycle
- Familiarity with Azure fundamentals including resource groups, identity, and Azure Resource Manager services
- Experience using the command line and Azure CLI
- A basic understanding of REST APIs and event-driven architectures
- Some experience working with databases such as NoSQL or PostgreSQL (recommended)
Target audience
This course is designed for:
- Developers building backend or AI-driven applications on Microsoft Azure
- Developers who need practical skills working with containerised compute, event-driven architectures, AI data services, and secure application development on Azure
Delegates will learn how to
By the end of this course, learners will be able to:
- Manage container images and build workflows using Azure Container Registry
- Deploy and manage containerised applications using Azure App Service, Azure Container Apps, and Azure Kubernetes Service
- Implement container scaling, configuration, and monitoring across Azure compute services
- Build and query AI data solutions using Azure Cosmos DB for NoSQL and Azure Database for PostgreSQL
- Implement vector search and retrieval patterns for AI applications
- Use Azure Managed Redis for caching, messaging, and vector search workloads
- Build event-driven architectures using Azure Service Bus and Azure Event Grid
- Develop serverless APIs and integrations using Azure Functions
- Secure applications using Azure Key Vault and Azure App Configuration
- Implement observability using OpenTelemetry and Azure Monitor
Outline
Store and manage containers in Azure Container Registry
- Azure Container Registry concepts
- Registries, repositories, and artifacts
- Build and run container images using ACR Tasks
- Tag and version container images
- Exercise: Build and manage a container image with ACR Tasks
Deploy containers to Azure App Service
- Deploy containers to Azure App Service
- Configure container runtime behaviour
- Configure application settings
- Observe and troubleshoot containerised applications
- Exercise: Deploy a container to Azure App Service
Deploy containers to Azure Container Apps
- Explore Container Apps environments
- Deploy a container app using Azure CLI and YAML
- Configure runtime settings with environment variables and secrets
- Configure image pull authentication for private registries
- Verify deployments using logs and status
- Exercise: Deploy a containerised backend API to Container Apps
Manage containers in Azure Container Apps
- Update images and manage revisions
- Manage the container app lifecycle
- Monitor logs and troubleshoot issues
- Configure health probes and diagnose failures
- Optimise container resources and scaling
- Exercise: Diagnose and fix a failing deployment
Scale containers in Azure Container Apps
- Configure scale rules for containerised workloads
- Implement event-driven scaling with KEDA
- Apply KEDA scalers for custom workloads
- Select compute resources for performance and cost
- Apply revision modes for traffic management
- Exercise: Configure autoscaling using KEDA triggers
Deploy applications to Azure Kubernetes Service
- Create Kubernetes deployment manifests
- Expose applications using Kubernetes services
- Deploy applications to Azure Kubernetes Service
- Exercise: Deploy an AI inference API to Azure Kubernetes Service
Configure applications on Azure Kubernetes Service
- Define ConfigMaps for application settings
- Implement secrets for sensitive data
- Attach persistent storage to applications
- Exercise: Configure applications on Azure Kubernetes Service
Monitor and troubleshoot applications on Azure Kubernetes Service
- Monitor application logs and metrics
- Troubleshoot pods and services
- Verify service connectivity and endpoints
- Exercise: Troubleshoot applications on Azure Kubernetes Service
Build queries for Azure Cosmos DB for NoSQL
- Explore Azure Cosmos DB for NoSQL
- Connect to Azure Cosmos DB using the SDK
- Perform data operations on items
- Write queries to retrieve document data
- Exercise: Build a RAG document store on Azure Cosmos DB for NoSQL
Implement vector search on Azure Cosmos DB for NoSQL
- Store and retrieve vector embeddings
- Execute vector similarity queries
- Combine vector search with metadata filters
- Use the change feed to refresh embeddings
- Exercise: Build a semantic search application with Azure Cosmos DB for NoSQL
Optimize query performance for Azure Cosmos DB for NoSQL
- Understand indexing in Azure Cosmos DB
- Configure range and composite indexes
- Tune vector indexes for embedding workloads
- Reduce RU costs through indexing strategies
- Choose appropriate consistency levels
- Exercise: Optimize query performance with vector indexes
Build and query with Azure Database for PostgreSQL
- Explore Azure Database for PostgreSQL
- Connect to PostgreSQL databases
- Create and manage schemas
- Query relational data
- Integrate database access with application code
- Exercise: Build an agent tool backend on Azure Database for PostgreSQL
Implement vector search with Azure Database for PostgreSQL
- Store and query embeddings using pgvector
- Perform vector similarity search
- Manage vector indexes and embedding updates
- Implement retrieval patterns for AI applications
- Exercise: Implement vector search on Azure Database for PostgreSQL
Optimize vector search in Azure Database for PostgreSQL
- Tune PostgreSQL for pgvector workloads
- Choose and configure vector indexes
- Optimize database data layout
- Scale for high-volume workloads
- Optimize connection management
- Exercise: Optimize vector search performance
Implement data operations in Azure Managed Redis
- Explore Azure Managed Redis features
- Use client libraries and development best practices
- Implement data storage and retrieval operations
- Exercise: Perform data operations in Azure Managed Redis
Implement event messaging with Azure Managed Redis
- Publish and subscribe using Redis pub/sub
- Implement task queues using Redis Streams
- Choose broadcast or coordinated messaging models
- Exercise: Publish and subscribe to events in Azure Managed Redis
Implement vector storage in Azure Managed Redis
- Index and query vector data
- Choose vector types and indexing strategies
- Optimize Redis data structures for vector workloads
- Exercise: Implement semantic search in Azure Managed Redis
Queue and process AI operations with Azure Service Bus
- Azure Service Bus messaging concepts
- Queues and topics with subscriptions
- Structure messages for AI workloads
- Implement reliable message processing
- Exercise: Process messages with Azure Service Bus
Develop event-driven AI workflows with Azure Event Grid
- Azure Event Grid concepts and event-driven architecture
- Work with event schemas and properties
- Configure delivery and retry policies
- Publish custom events from AI applications
- Exercise: Publish and receive events with Azure Event Grid
Build serverless AI backends with Azure Functions
- Azure Functions hosting and scaling
- Set up the local development environment
- Create triggers and bindings for AI integrations
- Manage secrets and configuration
- Configure identity and access
- Exercise: Create an MCP server with Azure Functions
Manage application secrets with Azure Key Vault
- Store and organise secrets, keys, and certificates
- Retrieve secrets using SDK client libraries
- Implement secret versioning and rotation strategies
- Apply caching strategies for secret retrieval
- Exercise: Manage secrets with Azure Key Vault
Manage application settings with Azure App Configuration
- Connect applications to Azure App Configuration
- Organise settings using labels and feature flags
- Reference Azure Key Vault secrets
- Determine appropriate configuration storage strategies
- Exercise: Retrieve settings and secrets from Azure App Configuration
Instrument an app with OpenTelemetry
- OpenTelemetry concepts and observability
- Add the OpenTelemetry SDK to an application
- Configure spans and traces
- Export telemetry to Azure Monitor
- Debug distributed application flows
- Exercise: Instrument an application with OpenTelemetry
Analyze application telemetry with logs and metrics
- Write KQL queries for Application Insights
- Analyse logs for errors and performance patterns
- Build dashboards for monitoring applications
- Create workbooks for interactive analysis
- Configure alerts for failures and anomalies
- Exercise: Query logs using KQL
Exams and assessments
This course prepares learners for the AI-200 examination. The examination is available separately.
Hands-on learning
This course includes lectures, demonstrations, and practical labs. Learners complete guided exercises throughout the course to deploy applications, configure Azure services, implement AI data solutions, and troubleshoot distributed applications in real-world scenarios.
Frequently asked questions
How can I create an account on myQA.com?
There are a number of ways to create an account. If you are a self-funder, simply select the "Create account" option on the login page.
If you have been booked onto a course by your company, you will receive a confirmation email. From this email, select "Sign into myQA" and you will be taken to the "Create account" page. Complete all of the details and select "Create account".
If you have the booking number you can also go here and select the "I have a booking number" option. Enter the booking reference and your surname. If the details match, you will be taken to the "Create account" page from where you can enter your details and confirm your account.
Find more answers to frequently asked questions in our FAQs: Bookings & Cancellations page.
How do QA’s virtual classroom courses work?
Our virtual classroom courses allow you to access award-winning classroom training, without leaving your home or office. Our learning professionals are specially trained on how to interact with remote attendees and our remote labs ensure all participants can take part in hands-on exercises wherever they are.
We use the WebEx video conferencing platform by Cisco. Before you book, check that you meet the WebEx system requirements and run a test meeting to ensure the software is compatible with your firewall settings. If it doesn’t work, try adjusting your settings or contact your IT department about permitting the website.
How do QA’s online courses work?
QA online courses, also commonly known as distance learning courses or elearning courses, take the form of interactive software designed for individual learning, but you will also have access to full support from our subject-matter experts for the duration of your course.
Once you have purchased the Online course and have completed your registration, you will receive the necessary details to enable you to immediately access it through our e-learning platform and you can start to learn straight away, from any compatible device. Access to the online learning platform is valid for one year from the booking date.
All courses are built around case studies and presented in an engaging format, which includes storytelling elements, video, audio and humour. Every case study is supported by sample documents and a collection of Knowledge Nuggets that provide more in-depth detail on the wider processes.
When will I receive my joining instructions?
Joining instructions for QA courses are sent two weeks prior to the course start date, or immediately if the booking is confirmed within this timeframe. For course bookings made via QA but delivered by a third-party supplier, joining instructions are sent to attendees prior to the training course, but timescales vary depending on each supplier’s terms. Read more FAQs.
When will I receive my certificate?
Certificates of Achievement are issued at the end the course, either as a hard copy or via email. Read more here.