FlashArray-Implementation-Specialist Pure Storage Pure Certified FlashArray Implementation Specialist (FAIS) Exam Free Practice Exam Questions (2026 Updated)

The puresetup initialization script automatically runs a series of network validation tests to ensure the array can reach default gateways, DNS servers, and Pure1. If the management network is not yet live or is air-gapped during the install, these tests will fail, potentially blocking the setup process.

To proceed with the initialization despite the missing network, the Implementation Engineer must append the --skip-management-connectivity-tests flag to the puresetup command.

This flag instructs the script to bypass the ping/DNS lookup checks on the management interface.

It allows the engineer to complete the array initialization (naming, IP assignment) so the array is "up" and ready for local config, with the understanding that full management connectivity will be established and verified later.

=========

Within the Purity//FA operating system architecture, dedicated NVRAM modules (used heavily in standard non-DFMD arrays to provide non-volatile write caching) are fundamentally treated as specialized drives by the software layer. They are physically installed into specific central chassis bays labeled NVB0, NVB1, NVB2, and NVB3.

Because they are classified as drive components, the primary and most direct command an Implementation Engineer should use to verify their physical installation, health, capacity, and update status is puredrive list. When this command is executed via the CLI, it generates a comprehensive table detailing every DirectFlash Module (DFM) and NVRAM module currently seated in the chassis.

The output explicitly shows the slot location (e.g., CH0.NVB0), the component's operational status (healthy, empty, evacuating, or updating), and its specific firmware version. While the purehw list command is excellent for viewing broader chassis components (like fans, temperature sensors, and controllers), puredrive list is the purpose-built command required to monitor the precise synchronization and firmware update phases of the NVRAM modules, especially crucial during a non-disruptive upgrade (NDU) when ensuring cache mirror integrity is paramount.

When expanding a Pure Storage FlashArray//XL130 R5 with an external DirectFlash Shelf (DFS), the backend connection between the shelf controllers and the main chassis relies on massive 100GbE bandwidth via the NVMe-oF (RoCE) protocol. Validating the Bill of Materials (BOM) before an onsite installation is a critical preparatory step to ensure the correct internal hardware was shipped to support this connection.

According to the official Pure Storage hardware matrix, the supported PCIe expansion card required for //XL series shelf connectivity is the FA-XL-100G Ethernet/RoCE 2-Port CX6 . This card utilizes the modern Mellanox/Nvidia ConnectX-6 (CX6) chipset, which is explicitly engineered to provide the necessary 100GbE RDMA capabilities to maintain ultra-low latency, NVMe-level speeds across the external storage fabric.

Option B (the CONNECTX-5 card) is an older, End-of-Sale component generally associated with legacy deployments or specific frontend iSCSI requirements, not the modern //XL backend loop. Option C (a 200G CX7 card) is not the standard validated BOM component for a single DFS loop on an //XL130 R5. Confirming the presence of the 100G CX6 card ensures the engineer has the exact hardware required to successfully cable the 100GbE backend ports.

During a controller upgrade (e.g., //X to //XL), the puresetup script attempts to migrate network configurations from the old controller's ports to the new controller's ports. If the script detects that certain ports configured on the source array are physically missing or "link down" on the target array, it halts to prevent a configuration mismatch that could cause a service outage.

The error message explicitly lists the affected ports. The correct resolution path is to:

Identify the services: Determine if the missing ports are critical (e.g., a replication link that hasn't been cabled yet) or non-critical (e.g., an unused interface).

Re-run with override: Execute the puresetup command again, this time appending the specific flags or arguments (often suggested in the error output or upgrade guide) to explicitly acknowledge and include those affected ports. This tells the script, "I know these ports are down/missing; proceed with the migration anyway."

This allows the upgrade logic to complete the configuration transfer so the new controller can boot, after which the engineer can physically troubleshoot the link status.

=========

ActiveCluster, Pure Storage's synchronous replication solution for zero RPO/RTO, currently supports a maximum of 2 arrays in a single active-active relationship (often referred to as a "Pod").

Architecture: The ActiveCluster architecture is strictly designed as a 1:1 synchronous pairing between two FlashArrays. This allows both arrays to serve reads and writes for the same volumes simultaneously.

Stretched Clustering: The limit of two arrays ensures that the synchronous acknowledgement (ACK) process for writes remains performant and manageable over the inter-site link. Adding a third array to the synchronous loop would exponentially increase write latency and complexity.

3-Data Center Configurations: While you can configure a "3DC" architecture, this involves one ActiveCluster pair (2 arrays) replicating asynchronously to a third, standalone array (ActiveCluster + ActiveDR or Async). However, the synchronous ActiveCluster domain itself never exceeds 2 arrays.

When an Implementation Engineer or storage administrator needs to configure the foundational networking for array-to-array replication, it is essential to distinguish between configuring the network interfaces and configuring the replication partnerships .

To set up the IP addresses, subnet masks, gateways, and assign the replication service to specific Ethernet ports (such as eth2 and eth3), the user must navigate to Settings > Network in the Purity GUI. This section of the interface is strictly dedicated to managing the physical and virtual network topology of the array. Here, the engineer defines which physical ports are allowed to handle replication traffic, ensuring it is isolated from frontend host I/O or management traffic.

It is a common misconception to navigate to "Storage > Array Connections" for this step. However, the "Array Connections" tab is used after the network settings are fully configured. "Array Connections" is where the administrator actually enters the Connection Key to establish the synchronous (ActiveCluster) or asynchronous replication link between two fully networked arrays. Therefore, the foundational IP configuration must always be completed first under the Settings > Network tab.

FlashArray//XL architectures offer the ability to leverage DirectMemory Modules (DMMs) to drastically accelerate read-intensive workloads. DMMs are specialized drives built on Storage Class Memory (SCM) technologies, such as Intel Optane. They act as a high-speed read cache tier, sitting seamlessly between the array's ultra-fast NVRAM (which handles incoming writes) and the standard DirectFlash Modules (which provide the bulk capacity).

Because the entire purpose of a DirectMemory Module is to provide the absolute lowest read latency possible, physical proximity to the controller's CPUs and direct access to internal PCIe lanes is mandatory. Therefore, DMMs must be installed directly into the primary FlashArray chassis in specifically designated slots.

Installing DMMs into an external DirectFlash Shelf (DFS) is strictly prohibited and physically unsupported. Routing read-cache traffic across an external NVMe-oF (RoCE) backend fabric—even at 100GbE speeds—would introduce microsecond latency overheads that completely defeat the performance benefits of Storage Class Memory. Furthermore, DMMs share the exact same physical U.2/NVMe drive slot form factor as standard capacity DFMs (making Option C false), and they are supported across multiple array models beyond just the //XL 170 (making Option B false). An Implementation Engineer must strictly validate the chassis population rules before inserting DMMs to ensure the system recognizes the cache tier correctly upon initialization.

The FlashArray//XL currently supports a maximum of 2 DirectFlash Shelves (DFS) .

The FlashArray//XL is a high-density, performance-optimized platform housed in a 5U chassis.

Rack Unit Math: According to the FlashArray//XL specifications and site planning guide, the system supports a maximum configuration footprint of 11 Rack Units (11U) .

The base controller chassis occupies 5U .

Each DirectFlash Shelf occupies 3U .

Therefore: 5U (Base) + 3U (Shelf 1) + 3U (Shelf 2) = 11U .

Capacity: Because the //XL chassis itself holds 40 DirectFlash Modules (compared to 20 in a standard //X), and each shelf holds 28 modules, a fully populated system with two shelves provides nearly 100 drives of capacity (40 + 28 + 28 = 96 drives). This massive density reduces the need for "daisy-chaining" large numbers of shelves like legacy SAS architectures. Adding a third shelf would push the total height to 14U, exceeding the current platform definition.

During a hardware upgrade, physical components are often moved or handled, leading to potential connection issues. If a specific port (like CT0.ETH14) that is expected to carry traffic shows 0.00 b/s and "Link Down" or similar status immediately after the controller is initialized, the most likely physical issue is an improperly seated transceiver (SFP) or cable.

The standard troubleshooting hierarchy dictates checking Layer 1 (Physical) first. Therefore, the engineer should ensure the SFP in CT0.ETH14 is fully seated and re-seat it if necessary . SFPs can easily become slightly dislodged during the cable swap from the old controller to the new one. Checking the seating is a quick, non-disruptive step that resolves a high percentage of "dead port" issues during upgrades. Swapping to a management port (Option A) is invalid because management ports often have different speeds or configurations, and asking the customer to reboot hosts (Option B) is premature and potentially disruptive before ruling out the physical array connection.

=========

The FlashArray//E (and the //XR4/R5 family) utilizes a modern architecture that moves away from the dedicated NVRAM modules found in legacy generations (like the //XR2 and //XR3). In those older systems, NVRAM was housed in specific PCIe cards plugged into the chassis.

In the FlashArray//E architecture, the Non-Volatile RAM (write buffer) functionality is Distributed directly onto the storage media itself. These specialized drives are called DFMDs (DirectFlash Modules with Distributed NVRAM).

By integrating the NVRAM into the DFMs, the array scales its write buffer cache linearly with capacity and removes the bottleneck of fixed NVRAM slots in the chassis. This allows for higher density and simplified hardware designs. During installation or inventory, engineers must distinguish between standard DFMs (which store data only) and DFMDs (which store data and act as the write cache), ensuring the correct number of DFMDs are present to form the system quorum.

=========

After finishing an upgrade or major maintenance event, it is standard practice to manually trigger a log upload to Pure1. This ensures that the most recent diagnostic data—covering the upgrade window itself—is available to Pure Storage Support for verification and historical record.

The command purearray phonehome --send-today is the standard syntax used to force an immediate upload of the current day's logs. This command packages the relevant logs from the upgrade period and pushes them to the Pure1 cloud.

Options like purearray phonehome --send-logs or purelogs --send-all are often incorrect syntax or deprecated aliases.

--send-today is specific and efficient, targeting exactly the timeframe relevant to the maintenance window just completed.

=========

Drive or shelf evacuation is a resource-intensive, background data mobility process within the Purity operating system. When an Implementation Engineer issues an evacuation command via the CLI (e.g., puredrive evacuate) or the GUI, the array begins transparently reading data blocks from the targeted DirectFlash Modules, recalculating parity, and destaging those blocks onto the remaining free capacity in the chassis or a connected swing shelf.

According to strict Pure Storage Implementation guidelines, only one evacuation process can be actively running on a FlashArray at any given time . The system architecture does not support queuing multiple, simultaneous drive or shelf evacuations, nor does it allow an administrator to arbitrarily inject new drives into an active evacuation job.

If an engineer attempts to issue a second evacuation command while the first is still running, the Purity operating system will immediately reject the command and return an error stating that an evacuation is already in progress. While it is technically possible to cancel an evacuation, doing so forces the array to halt its progress and leaves the data fragmented across the old and new drives, wasting time. The only supported and safe method is to let the current evacuation reach 100% completion, physically remove the evacuated drives, and then initiate a completely separate, new evacuation job for the second data pack.

Data evacuation is a background process used to move data off specific physical media (like a shelf or data pack) so it can be removed safely. Purity is designed to handle dynamic changes to evacuation requests efficiently.

If an evacuation is already running and additional hardware needs to be evacuated, the Implementation Engineer does not need to stop the current job or wait for it to finish. The correct procedure is to issue a new evacuation command specifying the additional packs or shelves. Purity will intelligently update the existing background job to include the new targets, queuing the data movement logic to ensure all specified hardware is cleared. This "add-to-flight" capability saves time and administrative overhead compared to cancelling and restarting the entire workflow.

=========

On standard Pure Storage FlashArray models, including the //XR2 and //XR3 generations, the hardware architecture relies heavily on dedicated, non-volatile memory (NVRAM) modules. These modules are responsible for safely ingesting incoming host writes and protecting data in flight against unexpected power loss or controller failures before the data is ultimately destaged to the capacity flash drives.

To maintain absolute high availability and guarantee there is no single point of failure within the write cache, this NVRAM must always be mirrored across separate physical modules. During the physical hardware installation, the Implementation Engineer populates the dedicated NVRAM bays located centrally on the front bezel of the chassis. According to official Pure Storage implementation guidelines, the primary pair of NVRAM modules must always be installed in the first two designated bays, which are explicitly labeled 0 and 1 (NVB0 and NVB1).

While higher-performance arrays in the series (like the //X70 and //X90) possess enough ingest bandwidth to require populating bays 2 and 3 as well, bays 0 and 1 are the universal minimum baseline that is definitively populated across every array in the series to ensure N+1 cache redundancy.

Within the Purity//FA operating system, specialized system variables, behavioral overrides, and feature flags are managed using "tunables." Tunables are typically set by Pure Storage Support or Implementation Engineers to address specific environmental edge cases, enable beta features, or manage hardware non-disruptive upgrade (HWNDU) states.

Once a maintenance window is complete or a tunable is no longer required, it must be carefully removed to return the array to its default operational state. The correct and officially supported Purity CLI command to remove a tunable is puretune --unset < tunable_name > .

Because FlashArray controllers operate in a highly available, clustered configuration, standard tunables applied to the array are generally mirrored. Executing puretune --unset from the active primary controller will cleanly strip the tunable from the configuration database, applying the change system-wide. Commands like pureadm do not exist in the standard Purity CLI, and puretune remove is incorrect syntax.

The command purenetwork list is used to identify the configuration and status of the array's logical network interfaces.

Command Output: Running purenetwork list provides a tabular view of all configured IP interfaces (Management, iSCSI, Replication). Critical columns in this output include:

Name: (e.g., vir0, eth0, eth1)

Address/Netmask: The IP configuration.

Gateway: Routing information.

Status: (e.g., "enabled" or "disabled").

Usage: An Implementation Engineer uses this command to verify that the management VIP and physical interfaces are correctly configured and legally "up" (enabled) in the Purity software stack.

Distinctions: While purehw list is used for physical hardware link status (e.g., cable plugged in/link light), purenetwork is the primary namespace for IP-level validation. Options B and C (--all, --eth) are not the primary standard syntax for the general status view in this specific context; the base command provides the necessary summary data for initial verification.

The output "Ping successful with CCM" is a specific success message returned by the puresupport test or purearray test connectivity checks. CCM stands for Cloud Connection Manager , which is the internal service or endpoint responsible for mediating the secure connection between the local FlashArray and the Pure1 cloud management platform.

When an Implementation Engineer sees this message, it confirms that the array can successfully resolve and reach the Pure1 infrastructure over the internet (specifically the pure1.purestorage.com or associated regional endpoints). This validates that:

DNS is functioning correctly (resolving the CCM hostname).

Firewall rules are permitting outbound HTTPS (port 443) traffic.

The array's management interface is routing correctly.

This connection is vital for "Phone Home" logs, Remote Assist sessions, and fleet management via the Pure1 mobile app or dashboard. It is distinct from the Fusion Fleet Coordinator (which manages fleet logic) and the cross-controller interconnect (which is internal hardware communication).

=========

On a new FlashArray//XR4 installation, the Implementation Engineer must run the cobalt_check.py script before executing puresetup newarray.

The FlashArray//XR4 represents a significant hardware architectural shift (internally codenamed or associated with the "Cobalt" platform generation). This platform introduces new PCIe layouts, NVMe backplanes, and controller components that require specific validation beyond the standard legacy checks. The cobalt_check.py script is a specialized hardware diagnostic tool pre-loaded on the manufacturing image of //XR4 controllers.

Its purpose is to verify that the specific hardware components of the R4 platform—such as the status of the internal NVMe interconnects, the correct population of the chassis, and the health of the new controller mainboard—are functioning within strict tolerances. Running this check ensures that the physical layer is 100% healthy before the Purity operating system attempts to initialize the database and claim the storage media. Option A (pureboot list) checks boot versions but not hardware health, and Option C (purehw list) is a general command that might not catch the specific low-level architectural issues the cobalt_check.py script is designed to identify on this specific generation.

To safely stop the Purity operating environment on a specific controller during a physical controller upgrade (such as upgrading from FlashArray//X to //XL or performing a chassis swap), the correct command is pureadm stop .

This command is a system administration utility located in the Linux shell of the controller (accessible via the puresh prompt when logged into the specific controller's physical IP address). It is designed to stop the local Purity services on the node where the command is executed.

Procedure: In a non-disruptive controller upgrade, the engineer manually fails over primary services to the peer controller. Then, they log into the controller designated for removal (e.g., CT0) and run pureadm stop. This ensures that all Purity processes, I/O handling, and cache operations are cleanly terminated and flushed before the hardware is physically powered down or removed.

Syntax: The pureadm tool generally operates on the local instance. Options B and C utilize invalid flags (--secondary or --controller) for this specific command context. The engineer must be physically logged into the target controller to execute the stop command for that node.