Practice Free FlashArray-Storage-Professional Pure Certified FlashArray Storage Professional Exam Questions Answers With Explanation

Understanding MTU: The Maximum Transmission Unit (MTU) defines the largest size of a packet or frame that can be sent in a single network transaction. The standard Ethernet MTU is 1500 bytes . Anything larger than 1500 bytes is referred to as a Jumbo Frame .

Replication Efficiency: Replication involves moving large amounts of data between arrays. Using standard 1500-byte frames results in higher overhead because the CPU must process a larger number of headers for the same amount of data. By increasing the MTU, the FlashArray can pack more data into each frame, reducing CPU interrupts and improving overall throughput.

The Pure Recommendation: Pure Storage specifically recommends an MTU of 9000 for both iSCSI and Replication traffic. This is the industry standard for Jumbo Frames that balances efficiency with compatibility across most enterprise-grade switches.

Configuration Requirements: It is critical to remember that MTU must be configured end-to-end . For an MTU of 9000 to work on the replication ports:

The FlashArray replication ports must be set to 9000.

The network switches along the path (and any routers/ISLs) must support and be configured for at least 9000.

The target array ' s replication ports must also be set to 9000.

Why 9216 (Option A) is incorrect: While some switches support a " Baby Giant " or slightly larger MTU like 9216 to account for VLAN tagging overhead, Pure ' s internal and best practice documentation specifically points to 9000 as the standard setting for the array ' s interface.

To provide true real-time data and alerts directly to a Network Operations Center (NOC) dashboard, the information must be sourced directly from the FlashArray . The FlashArray ' s Purity operating environment natively supports real-time data streaming and alerting integrations via protocols like Syslog, SNMP traps, and the local REST API. Polling the array directly or configuring it to push alerts guarantees that the NOC receives instantaneous, up-to-the-second notifications regarding array health, hardware faults, and performance metrics.

Here is why the other options are incorrect:

Pure1 (B): While Pure1 is Pure Storage ' s powerful, cloud-based monitoring and predictive analytics platform, it relies on phone-home telemetry data. This telemetry is batched and transmitted from the array to the Pure1 cloud on a short polling interval (typically a few minutes). Because of this transmission and processing interval, Pure1 provides near-real-time (lagging by a few minutes) and historical data. It is excellent for global fleet management and predictive support, but not for instantaneous, zero-latency NOC alerting.

Pure Performance Monitoring (A): This is a distractor. There is no standalone product or specific protocol in the Pure Storage ecosystem officially named " Pure Performance Monitoring. " Performance monitoring is simply a feature accessed via the FlashArray GUI/CLI or the Pure1 platform.

When configuring NVMe/TCP (or iSCSI) for optimal performance on a Pure Storage FlashArray, configuring Jumbo Frames (an MTU of 9000) end-to-end is a standard best practice.

The command ping -M do -s 8972 < ip_addr > is specifically used to verify Jumbo Frame configuration across the network.

The -M do flag sets the " Do Not Fragment " (DF) bit, meaning the network is not allowed to break the packet into smaller pieces.

The -s 8972 flag sets the ICMP data payload to 8972 bytes. When you add the standard 8-byte ICMP header and the 20-byte IP header, the total packet size equals exactly 9000 bytes.

If this ping command fails, it indicates that somewhere along the network path between the host (initiator) and the FlashArray (target), a switch port, router, or network interface is not configured to support an MTU of 9000. The packet is being dropped because it is too large and cannot be fragmented. The administrator must verify the MTU settings on every network hop (switches, routers, and host NICs) to resolve the issue.

Here is why the other options are incorrect:

Engage support to enable NVME/ TCP services (A): The failure of a Jumbo Frame ping test is a Layer 2/Layer 3 network configuration issue, not an indicator that the NVMe/TCP storage protocol service is disabled on the array.

Run the command from the target (C): While pinging from the FlashArray back to the host is a valid secondary troubleshooting step, it will likely also fail if the network path doesn ' t support Jumbo Frames. The actual resolution is to fix the MTU on the network hops.

In a VMware vSphere environment utilizing Virtual Volumes (vVols), a Protocol Endpoint (PE) acts as a crucial logical proxy or I/O access point between the ESXi hosts and the storage array.

Unlike traditional VMFS datastores where the host mounts a massive LUN and places all VM files inside it, vVols map individual virtual machine disks directly to native volumes on the FlashArray. Because a single ESXi host could potentially need to communicate with thousands of individual vVol volumes, it would be extremely inefficient to map every single one directly to the host. Instead, the ESXi host mounts the Protocol Endpoint , and the storage array uses this PE to dynamically route the I/O to the correct underlying vVol. On a Pure Storage FlashArray, creating and connecting a PE volume to your ESXi host groups is a mandatory prerequisite for setting up a vVol datastore.

Here is why the other options are incorrect:

It allows for volumes of the same name within host groups (A): Purity OS requires all volume names across the entire FlashArray to be completely unique, regardless of which host group they are connected to or whether a Protocol Endpoint is in use.

It is required to set Host Protocol (C): The host communication protocol (such as iSCSI, Fibre Channel, or NVMe-oF) is determined by the physical host bus adapters (HBAs), network interface cards (NICs), and the configuration of the Host object in Purity, not by the creation of a volume type like a PE.

Requirement for Lossless Ethernet: NVMe over RoCE (RDMA over Converged Ethernet) requires a lossless fabric to function correctly. Unlike standard iSCSI which uses TCP for error recovery, RoCE assumes the network will not drop packets. If the network is " lossy, " performance degrades significantly.

The Role of PFC: Priority Flow Control (PFC) (IEEE 802.1Qbb) is the specific mechanism used in Data Center Bridging (DCB) to provide flow control on a per-priority basis. It allows the switch to send a " pause " frame to the sender when buffers are full, preventing packet drops.

Symptom Analysis: In the scenario provided, the array itself is not overloaded ( " within the performance envelope " ). However, the addition of a new workload increased traffic to the point where buffer congestion occurred. Because PFC was likely misconfigured (either on the FlashArray ports, the network switches, or the host NICs), the network dropped packets instead of pausing traffic. This leads to " go-back-N " retransmissions and massive latency spikes that affect all workloads sharing that fabric.

Pure Storage Best Practices: Pure Storage documentation for NVMe-RoCE emphasizes that PFC must be enabled and consistent across the entire path. If there is a mismatch in PFC configuration, the resulting packet loss will cause the symptoms described: extreme latency and potential service outages.

Purity Active/Active Architecture: Pure Storage FlashArrays use an Active/Active controller architecture. Under normal operating conditions, both controllers (CT0 and CT1) are healthy and independently serve I/O through their respective physical Fibre Channel ports.

The Scenario (Controller Failover): The output provided shows that the host initiator is seeing target WWNs associated with both CT0 and CT1, but the " Target " column indicates they are all being reached via the paths currently managed by one controller or through a specific failover mechanism.

Virtual WWNs and Transparency: In a controller failover or maintenance scenario, Pure Storage utilizes a feature where the WWNs of the " failed " or " offline " controller are logically moved to or presented by the " surviving " controller. This ensures that the host ' s MPIO (Multi-path I/O) software does not see a permanent " Path Down " error for those specific WWNs, but rather a transition.

Analyzing the Output: When you see CT1 port WWNs (e.g., 52:4A:93:78:55:2D:E3:10) appearing in the connectivity table in a way that implies they are being routed or presented through the physical infrastructure of CT0, it indicates that the array is in a state where one controller is assuming the identity/connectivity of the other. This is a key troubleshooting indicator that the array is likely undergoing a controller reboot, a Purity upgrade, or has experienced a controller hardware failure.

Why A and B are incorrect: * Option A: Multipathing software on the host handles path failures, but it wouldn ' t cause the array to report WWNs in this specific " cross-presented " manner in a connectivity log.

Option B: If there were a total outage on CT1 without this presentation mechanism, the paths would simply show as " Disconnected " or be missing from the initiator ' s view entirely.

Pure Storage FlashArrays utilize Thin Provisioning as a core, always-on architectural principle. When a volume is created, the " size " assigned to it is merely a logical limit (a quota) presented to the host; no physical back-end flash capacity is allocated or " pinned " at the time of creation.

Because of this architecture, Purity allows administrators to create volumes that are significantly larger than the actual physical capacity of the array (this is known as over-provisioning). If an administrator accidentally selects PB (Petabytes) instead of GB, the Purity GUI will allow the volume to be created because it is a logical operation that doesn ' t immediately consume 1PB of physical flash. However, Purity includes a built-in safety check: if the requested logical size is exceptionally large or exceeds the current physical capacity of the array, the GUI will present a warning or confirmation prompt to ensure the administrator is aware of the massive logical size being provisioned before finalizing the change.

Here is why the other options are incorrect:

The volume will be created and space will immediately be used (A): This describes " Thick Provisioning, " which Pure Storage does not use. Space is only consumed on a FlashArray when unique data is actually written by the host and processed by the deduplication and compression engines.

The volume will not be created and a warning will be displayed (C): Purity does not strictly forbid over-provisioning. While it warns the user to prevent human error, it does not block the creation of the volume, as over-provisioning is a standard practice in thin-provisioned environments.

For FlashArray File Services (FA File), user authentication and mapping depend on the storage protocol being used. In an NFS-only environment, remote user authentication (resolving UNIX UIDs and GIDs to actual usernames and managing access) is typically handled via LDAP or NIS.

To configure this integration in the Purity GUI, the storage administrator must navigate to Settings > Access > Directory Services . This specific section allows the FlashArray to connect to a centralized directory server (such as OpenLDAP or even Active Directory providing LDAP services) to pull the necessary UNIX user and group attributes required for NFS file permissions to function properly.

Here is why the other options are incorrect:

Settings > Access > Create Active Directory Account (A): This specific menu path is used strictly for configuring native Active Directory (AD) computer accounts and joining the domain to support the SMB (Server Message Block) protocol. Since the scenario explicitly states the company is an " NFS only shop, " configuring an SMB AD account is not the correct step.

Settings > Access > File System (C): While you manage file-level exports and policies within the Purity file interface, the global configuration for remote user authentication and directory server integration lives under the dedicated Directory Services pane.

Definition of Unified Storage: In the storage industry, " Unified Storage " refers to a platform that can natively serve both Block-level storage (accessed via protocols like Fibre Channel, iSCSI, or NVMe-oF) and File-level storage (accessed via protocols like NFS or SMB) from a single pool of capacity and under a single management interface.

Pure Storage Implementation (FA File): Pure Storage achieved unified storage on the FlashArray through the introduction of Purity//FA File Services . Unlike traditional unified storage that often required a " gateway " or separate hardware " heads, " Pure’s implementation runs natively on the FlashArray controllers.

Shared Resources: On a unified FlashArray, the global storage pool is shared between volumes (Block) and file systems (File). All of Pure’s core data services—such as deduplication, compression, and SafeMode snapshots —apply globally across both block and file data.

Protocol Diversity: While Option A mentions NFS and SMB, those are strictly File protocols. Option C mentions iSCSI and FC, which are strictly Block protocols. Only Option B correctly identifies the combination of Block and File , which defines the " Unified " architecture of the FlashArray.

On a Pure Storage FlashArray, " System Space " is a specific GUI-reported metric. Purity has a predefined, hidden internal space budget—typically around 20% of the raw mapped capacity (which would be 2TB on a 10TB array)—reserved for internal array operations. This budget covers RAID/parity overhead, metadata, and reclaimable space (data from deleted volumes, snapshots, or overwritten blocks that are waiting for the backend garbage collection process to fully erase them from the flash chips).

Normally, this internal overhead stays below the 20% budget, and " System Space " displays as 0.00 in the GUI. However, if an administrator deletes a massive amount of data at once, causing the reclaimable space to exceed that 2TB budget, the overflow is prominently displayed in the GUI as " System Space. "

Here is why the other options are incorrect:

Virtual machines have not yet issued an unmap command (A): If a VMware VM deletes a file but the OS hasn ' t issued an UNMAP/TRIM command, the FlashArray is completely unaware that the data was deleted. Therefore, the array continues to report that capacity as standard Volume Space , not System Space.

More than 2TB of volume snapshots were destroyed (C): While destroying snapshots leads to reclaimable space, " reclaimable space " (Option B) is the specific, correct Purity architectural term and metric that the system uses to calculate the internal budget threshold.

API Evolution: Pure Storage introduced REST API 2.x to provide a more scalable, standardized, and performant way to automate FlashArray management. It uses a different authentication method (OAuth2 with API Clients) compared to the API Token-based method in 1.x.

Feature Freeze on 1.x: As of Purity 6.x and beyond, Pure Storage has designated REST API 1.x as " Legacy. " While 1.x is still supported for backward compatibility to ensure older scripts don ' t break, all new Purity features (such as specialized ActiveDR commands, advanced File Services, or new hardware capabilities) are only developed and exposed via REST API 2.x .

Side-by-Side Support: Contrary to option C, both versions are supported side-by-side on the same array. An administrator can run a script using 1.x for volume creation and another script using 2.x for performance monitoring simultaneously without contacting support.

Feature Parity: REST API 2.x has long since reached and exceeded the capabilities of 1.x. It offers improved filtering, pagination, and a more consistent object model (e.g., /volumes instead of multiple nested endpoints).

Best Practice: Pure Storage strongly recommends that all new automation projects use REST API 2.x to ensure access to the full suite of Purity features and to future-proof infrastructure-as-code (IaC) workflows.

Definition of Host Personality: In Purity//FA, a Host Personality is a setting applied to a host object that modifies how the FlashArray communicates with that specific initiator. It ensures the array sends the correct SCSI responses that the target Operating System (OS) expects. Common personalities include ESXi, AIX, HP-UX, and Hitachi-VSP.

The Importance of Timing: The best practice is to set the personality during the host creation phase , before any volumes are attached or I/O has commenced. This ensures that from the very first " Inquiry " command sent by the host, the FlashArray responds with the appropriate settings (such as specific VAAI primitives for ESXi or specific ALUA behaviors for other Unix variants).

Risks of Changing Later: While Purity allows you to change a host personality later, doing so while volumes are connected and I/O is active can be disruptive. For many operating systems, a change in personality requires the host to be rebooted or the storage paths to be " rescanned " to recognize the change in device capabilities.

Default Behavior: If no personality is selected, the FlashArray uses a " Generic " personality suitable for standard Windows and Linux distributions. However, for specialized hypervisors like ESXi , failing to set the personality correctly from the start can lead to performance issues or lack of support for hardware acceleration features.

Why Option C is incorrect: Changing the personality after volumes are connected is reactive rather than proactive. It increases the risk of the host misinterpreting the storage device ' s capabilities, potentially leading to mount failures or path instability.

Understanding Space Reporting: To understand this behavior, you have to look at how Purity calculates capacity. Pure Storage uses a data reduction engine where data is deduplicated and compressed.

Volume Space vs. Shared Space:

Volume Space: This represents the unique data belonging to a specific volume that is not shared with any other volume via deduplication or snapshots.

Shared Space: This represents the data that is common across multiple volumes or snapshots. If you have two volumes that are clones of each other, most of that data is " Shared. "

The " Shift " Mechanism: When a volume is deleted (and potentially eradicated), the data it once shared with other volumes no longer needs to be " shared. "

Imagine Volume A and Volume B share 100GB of data. That 100GB is accounted for in Shared Space .

If you delete Volume B, that 100GB of data is now only referenced by Volume A.

Consequently, that 100GB is moved from the Shared Space bucket into Volume A ' s Volume Space bucket.

Net Result: The total physical space used on the array remains the same initially, but the accounting shifts. You see a decrease in Shared Space and an identical increase in the Volume Space of the remaining volumes that held those deduplication references.

On a Pure Storage FlashArray, Ethernet ports operate at both a physical hardware layer and a logical network configuration layer. If you need to verify the actual physical negotiated port speed of an Ethernet port (for example, verifying if a 25GbE port negotiated down to 10GbE due to switch configurations or cable limitations), you must query the hardware layer directly.

The command purehw list --all --type eth interacts directly with the physical NIC hardware components to report their true link status, health, and dynamically negotiated hardware link speed.

Here is why the other options are incorrect:

purenetwork eth list -- all (B): The purenetwork command suite is primarily focused on the logical Layer 2/Layer 3 networking stack. It is used to configure and list IP addresses, subnet masks, MTU sizes (Jumbo Frames), and routing, rather than focusing on the physical hardware negotiation details of the NIC itself.

pureport list (A): The pureport command suite is specifically used for managing and viewing storage protocol target ports. An administrator would use this to list the array ' s Fibre Channel WWNs or iSCSI IQNs to configure host zoning or initiator connections, not to verify Ethernet link negotiation speeds.

Policy-Driven Automation: Pure Protect //DRaaS (Disaster Recovery as a Service) is built on a declarative policy engine. When you define a business policy (Protection Group or similar policy-based management), the system ' s primary goal is to bring the environment into compliance with the " Desired State " defined by that policy.

Retention Enforcement: When the retention period is reduced (e.g., from 7 days down to 3 days), the Purity/Pure Protect engine identifies that any existing snapshots or backups older than the new 3-day threshold are now " out of policy. "

Immediate Reclamation: Unlike some legacy backup systems that only apply new retention settings to future backups, Pure Storage ' s policy-driven architecture typically triggers an immediate cleanup of the now-obsolete data to reclaim space on the target. This ensures the environment matches the modified policy requirements immediately upon the policy update.

SafeMode Considerations: If SafeMode is enabled on the target, these " erased " backups will actually move into the " Destroyed " (but not yet eradicated) bucket for the duration of the SafeMode timer, providing a safety net against accidental policy changes or malicious deletions. However, from the perspective of the active DR policy, they are removed.

When physical links fail to establish—especially when using Direct Attach Copper (DAC) cables or Twinax—the most common culprit is a hardware compatibility mismatch. Pure Storage arrays have specific requirements for optics and cabling to ensure optimal signal integrity and performance.

The FlashArray Transceiver and Cable Support article (available on the Pure Storage Support portal) is the authoritative, verified resource for this scenario. It provides a comprehensive, constantly updated compatibility matrix detailing exactly which vendor DAC cables (e.g., Cisco, Brocade, Arista) and transceivers are officially validated and supported for use with specific FlashArray models and port types. If an unsupported DAC cable is used, the switch or host bus adapter (HBA) on the array might simply refuse to bring the link up.

Here is why the other options are incorrect for this specific issue:

The FlashArray User Guide (A): This guide is excellent for day-to-day administration (volume creation, host grouping, etc.) but is too broad to contain granular, constantly updating hardware compatibility matrices for specific cables.

The Port Usage and Definitions article (C): This document explains the logical and physical purpose of the ports on the back of the controllers (e.g., defining which ports are used for management, replication, or host connectivity), but it does not dictate hardware transceiver or cable interoperability.

SNMP Capabilities on FlashArray: Pure Storage FlashArrays support SNMP (Simple Network Management Protocol) versions v2c and v3. The primary use case for SNMP on the FlashArray is for integration with third-party monitoring tools (like SolarWinds, Nagios, or Zabbix) to provide a real-time health and performance heartbeat.

Performance Metrics (MIBs): The Pure Storage Management Information Base (MIB) specifically exposes high-level array performance metrics. These include the " Big Three " of storage performance: Latency (response time in microseconds), Bandwidth (throughput in bytes per second), and IOPS (I/O operations per second).

Scope of Monitoring: While the FlashArray GUI and CLI provide deep granularity (per host, per volume, or per pod), standard SNMP queries typically focus on array-wide performance and health status. Detailed " Host and volume performance " (Option B) is generally more effectively monitored via the Pure Storage REST API or the Pure1 VM Analytics, as SNMP is less efficient for pulling large tables of per-object data.

Capacity vs. Performance: While SNMP can report on capacity (Option C) through specific OIDs, the question specifically asks about performance statistics . In the context of Pure Storage monitoring documentation, the core performance metrics provided via SNMP traps and polling are latency, bandwidth, and IOPS.