Study guide
9.4 CN-Series, AI Runtime Security, and Edge Deployment Options
Palo Alto Networks Certified Next-Generation Firewall Engineer Exam
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Device Deployment & Architecture
1.1 Platform Selection & Sizing: Hardware, VM-Series, and Cloud NGFW Form Factors 1.2 Base PAN-OS 11.x System Settings, Management Interfaces, and Service Routes 1.3 Interface Types, Zone Topologies, and Virtual Wire Configurations 1.4 Site-to-Site VPN Tunnels: IPSec, GRE, and Quantum-Resistant Cryptography
2 Chapter 2: Routing, VRFs, and Virtual Routers
2.1 Virtual Routers and VRF Architecture in PAN-OS 11.x 2.2 Static Routing, BGP, and OSPF Configuration & Failover 2.3 Policy-Based Forwarding (PBF) and Path Monitoring
3 Chapter 3: NAT and High Availability Designs
3.1 Source, Destination, and Twice-NAT Policy Configurations 3.2 High Availability Active/Passive Architecture and State Synchronization 3.3 High Availability Active/Active Architecture and HA Clustering
4 Chapter 4: Panorama Management & Policy Hierarchy
4.1 Panorama Architecture: Collector Groups, Log Collectors, and Device Registration 4.2 Templates and Template Stacks Configuration 4.3 Device Groups, Shared Rulestacks, and Policy Hierarchy
5 Chapter 5: Strata Cloud Manager and AIOps
5.1 Strata Cloud Manager (SCM) Architecture and Cloud-Delivered Management 5.2 SCM Rulestacks, Folder Hierarchies, and Unified Policy Management 5.3 AIOps for NGFW: Telemetry, Proactive Best-Practice Audits, and Operational Insights
6 Chapter 6: Security Profiles and Content Inspection
6.1 Antivirus, Anti-Spyware, and DNS Security Profiles 6.2 Vulnerability Protection, Custom Signatures, and Threat Exceptions 6.3 URL Filtering, Advanced WildFire Analysis, and Inline Deep Learning
7 Chapter 7: Decryption Inspection & Policy
7.1 SSL Forward Proxy Architecture and Internal Certificate Authority Trust 7.2 SSL Inbound Inspection for Internal Web Servers 7.3 Decryption Exclusions, HSM Integration, and Troubleshooting Decryption Failures
8 Chapter 8: User Identity and GlobalProtect Remote Access
8.1 User-ID Architecture, Agentless/Agent Deployment, and Cloud Identity Engine (CIE) 8.2 GlobalProtect Portals, Gateways, and Authentication Methods (SAML, MFA) 8.3 Host Information Profile (HIP) Checks and Endpoint Security Enforcement
9 Chapter 9: Cloud NGFW, Automation, and API Integration
9.1 Cloud NGFW for AWS and Azure Architectures (GWLB and VWAN) 9.2 XML and REST API Automation with Palo Alto Networks Firewalls 9.3 Infrastructure as Code: Terraform and Ansible Automation for PAN-OS 9.4 CN-Series, AI Runtime Security, and Edge Deployment Options
10 Chapter 10: Virtual Systems, Logging, and Operational Monitoring
10.1 Virtual Systems (VSYS), Logical Routers, and Inter-VSYS Routing 10.2 Logging Architecture: Strata Logging Service, Log Forwarding, and Collectors 10.3 Application Command Center (ACC), Dashboards, and Custom Reporting 10.4 Explicit and Transparent Web Proxy on PAN-OS
9.4 CN-Series, AI Runtime Security, and Edge Deployment Options
Key Takeaways Explain This Topic AI
The NGFW Engineer blueprint requires selecting among five deployment form factors: PA-Series hardware, VM-Series virtual, CN-Series container, Cloud NGFW managed cloud service, and AI Runtime Security for AI workloads.
CN-Series is the containerized form of PAN-OS for Kubernetes and container orchestration platforms, inspecting east-west traffic between pods and namespaces where VM-Series cannot be inserted efficiently.
AI Runtime Security inspects traffic to and from AI models, large language models, and AI applications to block prompt injection, model/data exfiltration, toxic content, and vulnerable model usage.
Deployment-option selection is driven by the workload boundary: bare-metal hardware at the network edge, virtual machines in private cloud and branch, containers in Kubernetes, managed SaaS in public cloud, and inline inspection for AI inference endpoints.
All form factors share the PAN-OS single-pass inspection engine and can be managed by Panorama or Strata Cloud Manager for consistent policy.
Last updated: July 2026
9.4 CN-Series, AI Runtime Security, and Edge Deployment Options
The Integration and Automation domain (task 3.1) requires engineers to install the correct Palo Alto Networks deployment option for the target environment. The blueprint names five options: PA-Series, VM-Series, CN-Series, Cloud NGFW, and AI Runtime Security. The first three were covered in section 1.1 and Cloud NGFW was covered in section 9.1; this section completes the set with the containerized and AI-focused options.
CN-Series: Containerized NGFW for Kubernetes
CN-Series is the containerized form of the Palo Alto Networks NGFW, designed to run inside Kubernetes and container orchestration platforms. Where VM-Series deploys as a full virtual appliance at a network choke point, CN-Series deploys as containerized firewall pods that are placed directly in the cluster so they can inspect east-west pod-to-pod traffic that never leaves the cluster.
Deployment Models
DaemonSet model: A firewall pod runs on every worker node (or every node labeled for inspection) so that all node traffic is inspected locally. This maximizes coverage and avoids hairpinning traffic to a central inspection point.
Sidecar / Service-mesh model: The firewall is co-located with protected workloads to inspect specific application flows.
CN-Series for Kubernetes vs CN-Series for OpenShift: Both use the same container image lineage; OpenShift adds tighter integration with the Red Hat OpenShift operator and SCC constraints.
Key Characteristics
- Aspect CN-Series Behavior
- Traffic inspected East-west pod and service traffic inside the cluster, plus north-south at the cluster edge
- Insertion Kubernetes network plugins and service mesh integration; transparent to applications
- Management Managed by Strata Cloud Manager or Panorama like other NGFW form factors
- Scaling Scales horizontally with the cluster; firewall capacity grows with node count
CN-Series uses the same App-ID, Content-ID, and security profile stack as PAN-OS hardware and VM-Series so that policy authored once in Panorama or SCM applies consistently across all form factors.
CN-Series Architecture and Kubernetes Integration
CN-Series is deployed natively through Kubernetes orchestration. The firewall pods run as a DaemonSet , so a single kubectl apply or Helm chart deployment places a firewall pod on every labeled worker node in the cluster, and Kubernetes self-healing restarts any failed pod automatically. Traffic is steered to the firewall pods through supported Container Network Interface (CNI) plugins , which makes insertion transparent to applications — pods keep communicating using normal Kubernetes service discovery while the firewall inspects the flows in line.
CN-Series is supported across managed Kubernetes platforms — Google Kubernetes Engine (GKE), Amazon Elastic Kubernetes Service (EKS), Azure Kubernetes Service (AKS), and Red Hat OpenShift — and can also run in on-premises Kubernetes clusters. A dedicated CN-MGMT management pod handles the control plane for the firewall pods, and a Kubernetes plugin for Panorama (or the equivalent Strata Cloud Manager integration) translates native Kubernetes metadata such as namespace, labels, and service names into policy tags. This lets engineers write tag-based security policies that reference Kubernetes labels — for example, a rule that blocks traffic from a dev namespace to a prod-payments service — so that policy follows workloads as the scheduler reschedules pods across nodes.
Licensing and Scaling
CN-Series uses credit-based flexible licensing (Software NGFW credits) shared with VM-Series, so teams consume firewall capacity from a pool instead of licensing fixed appliances. Credits let security scale elastically with the cluster: as nodes are added for peak load, more firewall capacity is consumed; when nodes are removed, credits return to the pool. This consumption model aligns network-security cost with actual Kubernetes usage and is a common exam point because it differentiates CN-Series from the fixed-throughput PA-Series and the VM-Series bundle model. Because each firewall pod runs on a worker node, capacity scales horizontally with node count , and engineers size by the per-node session and throughput limits rather than by a single appliance's backplane.
AI Runtime Security
AI Runtime Security is the deployment option targeted at AI workloads. As organizations deploy large language models (LLMs), retrieval-augmented generation (RAG) pipelines, and AI agents that call external tools and APIs, the AI inference endpoint becomes a new attack surface that a traditional network firewall does not fully understand.
Threats AI Runtime Security Addresses
Prompt injection and jailbreaks: Malicious instructions embedded in user input or retrieved content that cause the model to ignore guardrails.
Model and data exfiltration: Attempts to extract training data, model weights, or sensitive RAG context through crafted queries.
Toxic and malicious content: Generation or retrieval of harmful content, including malware payloads returned by tool calls.
Vulnerable and malicious models: Detection of known-vulnerable or unapproved models being invoked by applications.
Tool and agent abuse: Exploitation of the external tools, APIs, and data sources that AI agents can call.
How It Is Deployed
AI Runtime Security inspects the API traffic between users, applications, and AI models (whether self-hosted or consumed from providers) so that policy can permit, block, or alert on prompts, completions, and tool calls based on detected threats. It is delivered as a cloud-delivered security service and integrates with Strata Cloud Manager for policy, giving the same operational model as the rest of the NGFW portfolio.
Intercept Modes
AI Runtime Security is delivered through two protection modes that map to where AI traffic is inspected:
Network Intercept: inline, real-time inspection of the network path in front of AI inference endpoints, covering all OSI layers 1–7. It sits like a traditional inspection point but understands AI prompt and completion semantics, blocking prompt injection, data leakage, model DoS, and toxic content in flight without changing the application.
API Intercept: Security-as-Code embedded directly in the application. The application calls the AI Runtime API (for example, through the Python aisecurity SDK) to scan each prompt and model response programmatically, then acts on the returned allow/block/alert verdict before presenting output to the user. This mode suits AI providers and apps where inline network insertion is impractical or where inspection must happen at the application layer.
A related capability, AI Model Security , scans model versions before deployment to catch vulnerabilities such as arbitrary code execution during model loading, unsafe deserialization, and neural backdoors, so only vetted models reach production. Together these give defense-in-depth across the AI lifecycle — model scanning pre-deployment, and runtime inspection once the model is serving traffic — all managed from Strata Cloud Manager under the same policy and reporting plane as the NGFW portfolio.
Decision Matrix: Choosing a Deployment Option
Workload Boundary Recommended Option Why
Physical data center perimeter / internet edge PA-Series Dedicated hardware crypto and signature offload for multi-gigabit inspection
Private cloud, branch, virtualized data center VM-Series Software firewall flexibly placed at any virtual choke point
Public cloud with managed-service preference Cloud NGFW Palo Alto manages scaling, updates, and infrastructure; customer keeps policy
- Kubernetes container clusters CN-Series Container-native inspection of east-west pod traffic
- AI models, LLMs, AI applications AI Runtime Security Understands prompts, completions, and tool-call semantics
- Common Management Plane
A recurring exam theme is that the five deployment options are not five separate products with five separate management planes. They are five insertion points for the same PAN-OS inspection engine, all manageable from Panorama or Strata Cloud Manager . When architecting a hybrid deployment, engineers should plan the object, tag, and rulestack hierarchy so that shared policy descends cleanly to hardware, virtual, container, cloud, and AI inspection points.