Cisco Certified Specialist: Data Center AI Infrastructure

Where AI runs is a design choice: in your data center, in the cloud, at the edge, or across them. You compare the models, learn what Cisco’s AI solutions, including Hyperfabric AI, set out to simplify, and decide when each fits.

• On-premises, cloud and hybrid AI
• Edge inference and its constraints
• Training clusters against inference farms
• Where Cisco’s AI solutions fit
• Hyperfabric AI in outline
• Choosing a model for a given workload

You build A placement recommendation that puts each stage of an AI project in the right location.

GPUs set the pace of everything else. You learn how GPU memory and interconnects limit performance, how servers pack GPUs, CPUs and network adapters, and how to match server configuration to a workload.

• GPU architecture and memory at a working level
• GPU-to-GPU links inside a server
• PCIe layout and network adapter placement
• CPU, memory and storage around the GPUs
• Server density and what limits it
• Matching GPU choice to training or inference

You build A server specification for one training workload, with the reasoning behind each part.

A GPU cluster is a network problem. You separate the back-end fabric that links GPUs from the front-end network, learn why collective operations stress bandwidth and tail latency, and size spine-leaf fabrics, oversubscription and links for them.

• Front-end and back-end networks
• Collective communication and why it needs bandwidth
• Spine-leaf topologies and rail-optimized designs
• Oversubscription and non-blocking fabrics
• Latency, tail latency and job completion time
• Link speeds, optics and cabling choices
• Hybrid cloud links for data and bursts

You build A sized fabric design for a GPU cluster, with link counts and oversubscription stated.

Idle GPUs waiting for data are the costliest fault. You compare storage designs for training data and checkpoints, learn where parallel file systems, object stores and NVMe fit, and plan how data moves between sites and clouds.

• Training data throughput requirements
• Parallel file systems and object storage
• NVMe and NVMe over fabrics
• Checkpoints and their write bursts
• Moving datasets between sites and clouds
• Keeping the storage network separate from the compute network

You build A storage design that feeds a GPU cluster, with a data movement plan.

Dense GPU racks hit physical limits before they hit software limits. You calculate rack power, compare air and liquid cooling, account for networking gear’s share, and judge whether a room can host a design.

• Rack power density and circuit planning
• Air cooling and its ceiling
• Liquid cooling approaches
• Power effectiveness and efficiency measures
• Cabling, airflow and optics power
• Phasing deployment to what the facility allows

You build A power and cooling budget for a GPU row, with the limit that binds first.

RDMA over Converged Ethernet moves data between GPUs without the CPU, but only if the network does not drop packets. You learn how RoCEv2 works and configure priority flow control, explicit congestion notification and enhanced transmission selection to keep it lossless.

• RDMA and why AI traffic uses it
• RoCEv2 packet and queue behavior
• Priority flow control and its dangers
• Explicit congestion notification and marking thresholds
• Enhanced transmission selection and traffic classes
• Congestion control algorithms for RoCE
• Pause storms and how to avoid them

You build A QoS configuration for a RoCEv2 fabric, with PFC, ECN and ETS settings explained.

A design means little until it is running. You build a fabric with Cisco’s management tools, apply templates and policy through Nexus Dashboard, and follow the Hyperfabric AI workflow from plan to a working cluster.

• Fabric underlay and overlay choices
• Planning a deployment with Nexus Dashboard
• Applying fabric templates and policies
• Day-zero provisioning of switches
• The Hyperfabric AI deployment flow
• Verifying the fabric before connecting servers

You build A deployed lab or documented fabric that passes a pre-production verification list.

Servers must be configured to match the fabric. You use policies and profiles to set BIOS, boot, network and adapter behavior, enable RDMA on server adapters, and manage firmware consistently across a cluster.

• Policies, templates and server profiles
• BIOS and boot settings for GPU servers
• Network and adapter policies for RDMA
• Managing servers from Intersight
• Firmware baselines across a cluster
• Checking that server and switch settings agree

You build A server profile and policy set that brings a GPU server up ready for RoCEv2.

Claims about speed need evidence. You run network, storage and training benchmarks, record a baseline, and learn which numbers describe a healthy cluster and which hide a bottleneck.

• Standard AI benchmark suites
• Collective communication tests
• Network bandwidth and latency tests
• Storage throughput testing
• GPU utilization and time-to-train measures
• Recording a baseline you can compare against

You build A benchmark report with baseline numbers for network, storage and GPU utilization.

A cluster that cannot be observed cannot be trusted. You collect streaming telemetry from switches and servers, watch the counters that matter for RDMA, and use Nexus Dashboard and Intersight to raise alerts before users feel a problem.

• Streaming telemetry compared with polling
• Interface, queue and drop counters
• PFC and ECN counters as early warnings
• Monitoring with Nexus Dashboard
• Monitoring servers and GPUs with Intersight
• Setting alert thresholds worth acting on

You build A monitoring dashboard and alert set that flags congestion before jobs slow down.

Slow training jobs rarely announce their cause. You correlate switch logs, server messages and telemetry to isolate congestion, link faults, misconfigured policy and thermal throttling, and fix what you find.

• Reading syslog and system messages
• Correlating events across devices by time
• Diagnosing congestion and pause storms
• Link flaps, optics and cabling faults
• Misaligned QoS settings between server and switch
• GPU throttling and thermal events

You build A troubleshooting write-up that traces a slow job to its root cause across three data sources.

Take one workload from requirements to a verified design. You size compute, network, storage and power, specify the lossless fabric and policies, plan monitoring, and show with benchmarks that the cluster does what you promised.

• Turning a workload into requirements
• Sizing compute, network, storage and power together
• Specifying fabric, QoS and server policy
• Planning telemetry and alerts
• Proving the design with benchmark results

You build A complete AI cluster design pack with sizing, configuration and benchmark evidence.