Practice Free FlashArray-Implementation-Specialist Pure Certified FlashArray Implementation Specialist (FAIS) Exam Exam Questions Answers With Explanation

A frequent challenge Implementation Engineers face in the field is arriving onsite for a physical deployment only to discover that the customer's networking team has not yet provisioned the Top-of-Rack (ToR) switches, routed the management VLANs, or provided active copper connections for the array's eth0 and eth1 ports.

Despite this lack of upstream network readiness, the physical installation and logical initialization of the FlashArray can still successfully proceed. The Implementation Engineer can power on the chassis, connect a laptop directly to the primary controller's serial console port, and run the puresetup newarray script. By utilizing the --skip-network-tests flag, the engineer forces the array to accept the configured IP addresses and initialize the storage cluster without requiring an active external network connection.

However, the operational consequence of this scenario is that the customer will be unable to log in to the array . While the array is fully built and technically running in the rack, the lack of provisioned management network ports means there is no physical path for the customer to access the web-based Purity GUI, establish an SSH session, or connect via the REST API. Consequently, they cannot provision volumes, configure host groups, or monitor the system until the network team finally activates the switch ports and patches the cables.

After executing the puredb run giveback --safe command during a manual controller upgrade or specific non-disruptive upgrade (NDU) procedure, the Implementation Engineer must wait for 10 minutes before proceeding to the next step (typically upgrading the peer controller).

The giveback command instructs the recently upgraded controller (e.g., CT0) to resume its primary role and take back ownership of its assigned storage resources and I/O handling from the peer controller. This process triggers a failover event for the host multipathing software.

Path Stabilization: The 10-minute wait time is a critical safety buffer mandated to ensure that all host-side multipathing drivers (MPIO) have successfully recognized the restored paths to the upgraded controller and have stabilized.

Risk Mitigation: Proceeding too quickly—before the hosts have fully settled and paths are marked as "Active/Optimized"—could lead to an "all paths down" (APD) scenario when the second controller is taken offline for its upgrade. This wait time verifies that the upgraded node is fully functional and carrying load, adhering to the strict "availability first" philosophy of FlashArray upgrades.

Understanding the hardware architecture of the Pure Storage FlashArray//E is crucial for proper deployment and capacity management. The FlashArray//E (and FlashBlade//E) family was specifically engineered to deliver an all-flash solution for capacity-optimized, tier-2 workloads and unstructured data repositories, aiming to replace legacy spinning disk (HDD) environments entirely.

To achieve this massive storage density at a disruptive price point, the //E series exclusively utilizes Quad-Level Cell (QLC) flash. While older arrays (like the //X50) use strictly dedicated NVRAM modules centrally located in the chassis, and higher-end TLC arrays (like the //XL) use DirectFlash Modules with Distributed NVRAM (DFMDs), the FlashArray//E utilizes a highly specialized drive.

On the FlashArray//E, the non-volatile write cache is distributed across DFMes . "DFMe" is the specific Pure Storage hardware nomenclature for a QLC-based DirectFlash Module that includes integrated, distributed NVRAM. By moving the NVRAM directly onto the QLC capacity modules, the //E architecture eliminates the need for dedicated NVRAM bays, streamlines the write path, and allows the write cache bandwidth to scale linearly as the customer adds more capacity to the system.

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).

=========

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.

=========

The FlashArray//XR4 architecture utilizes massive 100GbE RDMA over Converged Ethernet (RoCE) for its backend loops to maintain NVMe-level performance across external expansion shelves. Because of the sheer bandwidth requirements, specific port and slot assignments are strictly regulated by the Purity operating system.

On a standard //XR4 model, the controllers feature dedicated, integrated 100GbE ports on the motherboard (typically enumerated as eth18 and eth19) which are strictly reserved for connecting the first DirectFlash Shelf loop. When an Implementation Engineer needs to install a second DirectFlash Shelf, those onboard ports are already fully saturated.

To establish a new dedicated backend fabric loop for the second shelf, the engineer must install an additional dual-port 100GbE RoCE PCIe expansion card into a designated slot (typically Slot 4). Once this card is properly seated, cabled, and recognized by the Purity operating system, it enumerates the new high-speed network interfaces natively as ETH6 and ETH7 . The Implementation Engineer must use these exact interfaces to connect the shelf to ensure the backend topology passes the mandatory pre-flight validation scripts and functions at optimal NVMe-oF speeds.

The FlashArray//XR4 introduces a new hardware platform architecture (internally codenamed or associated with "Cobalt" components for its BMC and chassis management). During the manufacturing and initial deployment phase, specific validation scripts are used to ensure the platform hardware is correctly initialized before the Purity Operating Environment takes over.

For a new install of a FlashArray//XR4, the Implementation Engineer is often required to run cobalt check . py (or cobalt_check.py).

This engineering-level Python script queries the Baseboard Management Controller (BMC) and internal sensors to verify that the chassis components, fans, and power delivery systems are reporting "Healthy" status specifically for the R4 architecture.

Running this before puresetup prevents the setup process from failing midway due to a hardware initialization error. It acts as a "pre-flight" hardware validation specific to the R4 generation's new chipset and management subsystem.

=========

To correctly configure the proxy settings for Phonehome and Remote Assist on a FlashArray, the Implementation Engineer requires the Protocol prefix (HTTP/HTTPS) and the Port number in addition to the IP address.

The Purity operating system requires a complete URL structure to establish a connection through a proxy server. A raw IP address like "10.24.18.120" is insufficient because the array does not know which communication protocol to use or which listening port the proxy server is monitoring.

Correct Format: The required input format is typically scheme://host:port. For example, https://10.24.18.120:8080 or http://10.24.18.120:3128.

Why it's critical: Without the port, the connection will likely time out or be rejected. Without the protocol (http vs. https), the handshake may fail. While credentials (username/password) might be required if the proxy enforces authentication, they are optional depending on the customer's network policy. However, the port and protocol are always technically mandatory to form a valid network socket connection.

The command to check I/O health and validate connectivity after a controller upgrade is purehost monitor --balance .

Following an upgrade (especially after a controller reboot or failover/giveback), it is essential to verify that the host Multipath I/O (MPIO) drivers have re-established connectivity to all paths.

purehost monitor : Displays real-time performance statistics (IOPS, Bandwidth, Latency) for connected hosts.

--balance : This specific flag breaks down the metrics per initiator (HBA port) for each host.

Why it's used: An Implementation Engineer uses this to look for "imbalanced" flow. If one initiator shows high IOPS and another shows zero, it indicates a dead path, a zoning issue, or an MPIO driver that failed to recover the path to the upgraded controller. Options A and B provide static configuration lists (mappings and WWNs) but do not show live I/O flow, making them insufficient for health monitoring.

The FlashArray//X20 R4 operates with a minimum AC voltage input of approximately 90 VAC .

The FlashArray//X series (specifically the entry-to-mid-range models like the X10, X20, and X50) utilizes high-efficiency Power Supply Units (PSUs) designed with auto-ranging capabilities. These PSUs conform to standard global power infrastructure requirements, supporting a nominal input range of 100V to 240V AC (50/60 Hz).

Low-Line Support: Because the X20 is an entry-level enterprise array often deployed in diverse environments (including edge locations or standard office server rooms), it fully supports "low-line" power (100-120V nominal). The technical minimum tolerance for these power supplies typically extends down to 90 VAC to account for voltage sags or fluctuations.

Contrast with High-End: Larger, higher-density systems like the FlashArray//XL or fully loaded high-performance chassis configurations often require "high-line" power (200V-240V) to deliver sufficient wattage efficiently. However, the X20 R4 does not have this restriction. Therefore, Option A (90V) represents the correct minimum floor, whereas Options B and C represent high-line voltages that are supported but not required for minimum operation.

The FlashArray//XR4 architecture fundamentally changed how external capacity is attached compared to older SAS-based or early NVMe platforms. Because DirectFlash Shelves (DFS) utilize massive 100GbE RDMA over Converged Ethernet (RoCE) for their backend loops to maintain NVMe-level performance, specific port and slot assignments are heavily regulated.

On an //XR4 model (such as the //X70 R4 or //X90 R4), the controllers feature dedicated, integrated 100GbE ports on the motherboard (specifically eth18 and eth19) which are strictly reserved for the first DirectFlash Shelf loop.

However, when an Implementation Engineer needs to install a second DirectFlash Shelf, the integrated onboard ports are already fully saturated. Pure Storage does not support daisy-chaining NVMe-oF RoCE shelves in the same manner as legacy SAS enclosures. Instead, a new dedicated backend fabric loop must be established. To accomplish this, the engineer must install an additional 100GbE RoCE PCIe expansion card. According to the official //XR4 PCIe Slot Population Matrix, the designated location for this secondary backend expansion card is PCIe Slot 4 . Installing the card into other frontend-designated slots (like Slot 0 or Slot 3) will trigger a topology mismatch during the array's pre-flight hardware checks and prevent the new shelf from initializing.

Upgrading from a fully populated FlashArray//X90 R3 to a FlashArray//XL introduces a unique set of hardware migration challenges. To facilitate this massive transition, Pure Storage utilizes a feature called Shelf Personality Mode (SPM). In SPM, the legacy //X90 controllers temporarily act as a "dumb" NVMe-oF expansion shelf attached to the new //XL controllers, allowing the capacity drives to be transparently migrated without external swing hardware.

However, DirectMemory Modules (DMMs)—which are high-speed Storage Class Memory (SCM) drives used strictly for read caching—are handled differently than standard capacity DirectFlash Modules (DFMs). DMMs do not hold persistent, uniquely resilient user data; they hold a volatile copy of hot read blocks.

While the system is still operating in Shelf Personality Mode, the official Hardware NDU procedure dictates that the Implementation Engineer cannot simply yank the DMMs out, nor can they be migrated collectively as a "data pack." Instead, the engineer must evacuate and remove each DMM one-by-one, and set them aside . By initiating a manual evacuation on a DMM, Purity gracefully flushes the read cache mapping for that specific module. Once fully evacuated, the drive is safely removed from the legacy //X90 chassis. After the HWNDU is completely finished and the //XL is operating independently, the engineer can then re-insert those compatible DMMs into specific designated slots (typically slots 20-39) on the new //XL chassis to rebuild the cache tier.

During a Hardware Non-Disruptive Upgrade (HWNDU), such as a controller swap, ensuring that the frontend host multi-pathing is perfectly healthy before taking a node offline is the single most critical safety check. If an Implementation Engineer initiates a failover while host I/O is unbalanced or single-pathed, it will cause an immediate All-Paths-Down (APD) event and crash the customer's applications.

While standard commands like pureport list --initiator are excellent for verifying that the physical fibre channel or iSCSI links are logged in, they do not confirm that data is actively flowing across them. To truly validate I/O health and multipath distribution, the engineer must run the purehost monitor --balance command.

This specialized CLI tool forces the FlashArray to take a brief, active sample of incoming read and write commands (defaulting to a 5-second interval) across all host initiators. It calculates the traffic distribution and displays the relative percentage of I/Os for each initiator path. A well-balanced, healthy host utilizing proper MPIO policies (like VMware's Round Robin) will show traffic evenly distributed across all available paths within a few percentage points. If the output reveals that 100% of the traffic is pinned to a single controller's port, the engineer immediately knows there is a zoning or host-side MPIO misconfiguration that must be resolved before proceeding with the upgrade.

During the initial deployment phase of a FlashArray, the puresetup user is utilized to run the initial configuration scripts (setting IPs, array name, etc.). However, once the array initialization is complete and the Purity operating system is fully running, the puresetup account is effectively disabled or restricted from performing standard administrative tasks.

For all subsequent operations, including running final health checks, verifying services, and performing day-to-day management, the Implementation Engineer must switch to the pureuser account. This is the default administrative superuser for the FlashArray.

The pureuser account has full privileges to run commands like purearray list, pureadm list, and other validation tools required to sign off on the installation. The pureeng account is reserved strictly for internal Pure Storage Engineering use and is not available for standard implementation tasks. Therefore, attempting to log in as puresetup after the array is configured will often result in authentication failure or a restricted shell that does not allow for the necessary health validation commands.

=========

The FlashArray//E connects to its DirectFlash Shelves (DFS) using 25Gb Ethernet (RoCE) .

The FlashArray//E is the "Capacity Optimized" member of the FlashArray family, designed to replace spinning disk repositories with all-flash efficiency. While the high-performance FlashArray//XL utilizes 100GbE for its backend NVMe-oF connectivity to maximize throughput for mission-critical databases, the //E prioritizes cost-efficiency, density, and power consumption.

Architecture: To maintain this efficiency balance, the backend connectivity for expansion shelves on the //E platform is standardized on 25GbE . This provides ample bandwidth for the QLC-based workloads (typically unstructured data, repository, or Tier 2 block) without the higher cost and power draw of 100GbE optics and controllers.

Comparison: Option A (40G) is a legacy QSFP standard not used in modern Pure backend designs. Option C (100G) is reserved for the performance-tier //XL and high-end //X models.

Pure Storage enforces strict naming conventions for FlashArrays to ensure compatibility with network protocols (like DNS), replication pairing, and fleet management tools. The allowable character set for an array name is alphanumeric characters (A-Z, a-z, 0-9) and hyphens (-).

The proposed name "corporate Lab-0L" contains a space character between "corporate" and "Lab-0L". FlashArray names cannot contain spaces .

Hyphens (Option A) are allowed and commonly used (e.g., FlashArray-01).

Numbers (Option B) are allowed (e.g., Lab-01).

To resolve the error, the Implementation Engineer should replace the space with a hyphen or remove it entirely (e.g., corporate-Lab-0L or corporateLab-0L). This restriction prevents issues with CLI parsing and host hostname resolution where spaces are often interpreted as delimiters.

To meet the requirement of deploying a specific, newer Purity version (6.1.21) on a factory-fresh array that arrived with older code (5.3.8), the most efficient and correct procedure for an Implementation Engineer is to create a bootable USB stick with the target 6.1.21 ISO and reimage the controllers .

The "Factory Reset" or re-imaging process is a supported method for initial installation when the desired software baseline differs significantly from what is pre-loaded. Since the array contains no customer data yet, re-imaging is non-destructive to business operations and avoids the time-consuming process of initializing the array on old code, registering it, and then performing a multi-step software upgrade (Option C).

Procedure: The engineer downloads the specific Purity ISO from the Pure Storage Support portal, uses a tool like Rufus or Etcher (or the pureinstall utility) to create the bootable media, and boots the controllers from this USB to lay down the fresh image.

Option B is incorrect because copying .ppkg files is part of an online upgrade workflow for running systems, not a re-imaging process for a raw box.

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.

FlashArray controllers operate in an Active/Active high-availability cluster. Each controller (CT0 and CT1) has its own physical IP address for hardware-level management. However, Purity configures a Virtual IP (VIP) that floats between the two controllers.

The Virtual management IP is the recommended address for all administrative access, including the GUI, CLI, and API integrations. Using the VIP ensures High Availability (HA) for management sessions. If an Implementation Engineer were to log in directly to CT0's IP and CT0 subsequently rebooted (e.g., during an NDU or failure), the management session would be disconnected.

By contrast, the VIP automatically fails over to the surviving controller (CT1) in the event of a disruption, allowing the management session (and the GUI) to remain accessible. This abstraction layer simplifies administration, as the user does not need to know which controller is currently "primary" for management tasks. Direct controller IPs are typically reserved for specific hardware troubleshooting steps where accessing a specific node is required.

=========

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.

When submitting a Pure Engagement Request (PER) or an Implementation Workbook (IWB) for a new Pure Storage FlashArray deployment, adhering to the strict naming conventions of the Purity//FA operating system is critical to ensure a smooth, error-free initialization. In this scenario, attempting to name the array "123" will cause the puresetup script to immediately reject the configuration.

According to the official FlashArray deployment documentation, a valid array name must adhere to specific alphanumeric rules. While the name can certainly contain numbers and hyphens (e.g., Prod-Array-01), it must always begin with a letter . It cannot begin with a digit, nor can it consist entirely of numbers. Furthermore, the name must be between 1 and 63 characters in length, and it cannot end with a hyphen.

Because "123" begins with a numeric digit, it violates the foundational naming schema required by the Purity OS for DNS resolution, Call Home telemetry tagging, and ActiveCluster synchronous replication identification. The Implementation Engineer must work with the customer to revise the array name in the IWB to a compliant format (such as FA-123 or Storage123) before proceeding with the onsite deployment and running the serial console initialization scripts.

A swing shelf (temporary external capacity) is required during a SAS-to-NVMe (Evergreen) upgrade specifically when there is insufficient free space elsewhere in the array to evacuate the data residing in the legacy chassis.

The Evergreen "Stateless" or XFORM upgrade involves replacing the legacy SAS-based controller chassis (which contains SAS SSDs) with a new NVMe-based FlashArray//X chassis (which uses DirectFlash Modules).

Evacuation Requirement: Before the old chassis can be removed, the data on its internal drives must be moved to a safe location. If the customer already has external SAS expansion shelves with enough free space to hold this data, Purity will transparently migrate the data there, and no swing shelf is needed.

Swing Shelf Scenario: If the array is highly utilized (e.g., the chassis is full and external shelves are full or non-existent), the Implementation Engineer must attach a temporary "swing shelf" provided by Pure Storage. This shelf acts as the evacuation target. Once the data is moved to the swing shelf, the old chassis is replaced. The data is then migrated back from the swing shelf to the new NVMe media in the new chassis, and the swing shelf is returned.

During a standard Pure Storage FlashArray deployment, the Implementation Engineer relies on the puresetup serial console utility to configure the management network profile. This includes defining IP addresses, subnet masks, gateways, and foundational core services like DNS, NTP, and SMTP (which are critical for resolving Pure1 addresses, synchronizing cluster time, and sending Call Home telemetry alerts).

By default, as soon as these parameters are entered, the Purity operating system actively initiates a network handshake to test connectivity to the specified servers. If the customer's environment is experiencing an active network outage—or if the Top-of-Rack switches have not yet been fully configured to route the array's management subnet—the setup script's automated validation checks will inevitably fail.

However, this failure does not halt the deployment or corrupt the initialization process. The puresetup utility is intelligently designed with deployment flexibility in mind. The engineer will receive a clear warning on the console that the validation checks failed, but they are given the interactive option to manually bypass the warning and commit the configuration anyway. As described in Option C, the installation will successfully complete, and the Purity operating system will fully boot. Once the customer eventually resolves the upstream network outage, the array's management interfaces will automatically begin resolving DNS and syncing with NTP, and the engineer can verify their status post-installation.

ActiveCluster (AC) is the enablement feature that introduces Mirrored Write statistics into the Analysis section of the Purity GUI.

ActiveCluster provides synchronous replication (active-active) between two FlashArrays. In this configuration, every write request from a host must be committed to the NVRAM of both arrays before an acknowledgement is sent back to the host. This ensures zero Recovery Point Objective (RPO). Because this synchronous process introduces a latency component related to the network round-trip and the remote array's acknowledgement, Purity exposes a specific metric called "Mirrored Write" latency.

This metric allows administrators to distinguish between the local array's write processing time and the time spent waiting for the replication partner. It is critical for troubleshooting performance in stretched-cluster environments; if write latency spikes, the "Mirrored Write" stat helps determine if the bottleneck is the inter-site link (WAN) or the remote array. Neither FA File (NAS services) nor ActiveDR (asynchronous/near-sync replication) generate this specific synchronous write metric in the Analysis dashboard.

A valid transfer path for re-using Fibre Channel (FC) cards during a controller upgrade includes moving cards from a FlashArray//M to a FlashArray//XR2 or //XR3 .

The FlashArray hardware compatibility matrix supports the migration of specific legacy hardware components to ensure investment protection for customers. The 16Gb Fibre Channel PCIe cards originally deployed in FlashArray//M controllers are physically and electrically compatible with the PCIe risers found in the FlashArray//X R2 and R3 generations.

When performing a "Stateless" upgrade (where the chassis/controllers are replaced but data drives or cards might be retained), the Implementation Engineer can physically transfer these FC HBAs from the retiring //M chassis into the new //X chassis (assuming the target chassis has the appropriate open slots and the cards meet the minimum speed requirements, typically 16Gb or 32Gb). Option B is the most comprehensive correct answer recognized by the exam, confirming that the //M series cards can land in either of the specified //X generations (R2 or R3). Option C is also physically possible but the specific exam context for "reuse" highlights the inter-generational leap from M to X.

, formatted as requested.

The upgrade from a FlashArray//X10 (or X20) to a FlashArray//X50 requires a mandatory power supply unit (PSU) upgrade .

While the FlashArray//X series utilizes a shared chassis design (3U) for models X10 through X90, the power requirements differ significantly between the entry-level and performance-tier controllers.

X10/X20: These models typically ship with 1000W or 1200W power supplies, which are sufficient for their lower-power CPUs and component loads.

X50/X70/X90: These "Performance" class arrays utilize higher-wattage Intel Xeon processors and often support denser NVMe configurations, necessitating 1600W power supplies to ensure stability and N+1 redundancy.

When a customer performs a Data-in-Place upgrade (swapping controllers) from an X10 to an X50, the existing chassis is retained, but the lower-capacity PSUs must be physically swapped for the high-capacity 1600W units to support the new X50 controllers. Conversely, upgrades like X50 > X70 (Option B) or R2 > R3 (Option C) typically occur within the same power tier, utilizing the existing 1600W PSUs.

In a Non-Disruptive Upgrade (NDU) scenario, the goal is to replace the compute and control logic of the array while preserving the existing data and minimizing hardware waste. When upgrading from a FlashArray//X70R2 to an //X70R4, the primary components that change are the Controllers themselves. The chassis, power supplies, and NVRAM modules (depending on the specific generation jump and health) can often be reused or are not the primary target of the replacement in a standard NDU kit.

If a complete array is shipped by mistake (often called a "greenfield" or "net-new" array shipment) instead of the specific upgrade kit, the engineer should only extract and use the Controllers from the new shipment. The existing chassis and its passive components (like the midplane and power supplies) are already racked, cabled, and functioning. Swapping the chassis or power supplies would turn the operation into a disruptive migration or a much more complex "chassis replacement" procedure, which is unnecessary for a controller upgrade.

Therefore, the engineer should unpack the new controllers, perform the NDU procedure to replace the old controllers one by one, and leave the rest of the new hardware (chassis, empty slots, etc.) as spare or return it. This approach adheres to the NDU procedure of swapping the "brains" of the storage while keeping the "body" (chassis and drives) intact.

=========

To facilitate a Capacity Consolidation (CapCon) in a chassis that is physically full (both data pack slots occupied) and logically utilized above the threshold to allow internal evacuation, the standard procedure requires temporary external capacity , often referred to as "swing gear."

In this scenario, the FlashArray//X20 chassis is fully populated with two 22TB data packs. Since there are no empty slots to insert the new 45TB pack, one of the existing packs must be removed first. However, with the array at 80% usage , the data residing on the pack designated for removal (roughly half the raw capacity) cannot fit into the remaining free space of the other pack.

Therefore, Pure Storage Support will provision a DirectFlash Shelf (DFS) containing temporary capacity (e.g., a 63TB pack as mentioned in Option B). The Implementation Engineer attaches this shelf, adds it to the system, and utilizes it as a destination to evacuate data from the old 22TB pack. Once the old pack is empty and removed, the new 45TB pack is installed into the chassis. Finally, the data is moved from the temporary shelf back into the new chassis capacity, and the temporary shelf is disconnected and returned. Option A is incorrect because an empty shelf provides no storage to offload data, and Option C is operationally unfeasible for most customers.

Configuring replication involves two distinct steps: setting up the physical network interfaces (IP addresses) and then connecting the arrays (partnerships). The question specifically asks where to configure replication IP settings .

In the Purity//FA GUI, the configuration of Ethernet interfaces—regardless of their use for Management, iSCSI, or Replication—is centralized under the Settings tab, specifically within the Network sub-menu.

Settings > Network : Here, the user selects the Ethernet ports (e.g., eth2, eth3) designated for replication and assigns them IP addresses, netmasks, and gateways (or assigns them to a subnet).

Storage > Array Connections : This is where you use those configured IPs to connect to a remote array and establish the replication partnership.

Storage > Replication : This tab is used to monitor replication sessions and manage protection groups (snapshots/policies), not to configure the underlying interface IPs.

=========

When adding a second DirectFlash Shelf to a FlashArray//XL , the connectivity utilizes PCIe Slot 6 (in conjunction with Slot 0).

FlashArray//XL Architecture: The //XL chassis distributes its backend NVMe-oF (100GbE RoCE) connectivity across two dedicated PCIe slots to ensure redundancy and maximum bandwidth. As established in hardware diagrams, Slot 0 (lower riser) and Slot 6 (upper riser) are the designated slots for the 2-port 100GbE backend cards.

Expansion Logic:

First Shelf: Typically connects to Port 0 of the card in Slot 0 and Port 0 of the card in Slot 6 (providing HA).

Second Shelf: Connects to the remaining ports (Port 1) on the same cards in Slot 0 and Slot 6.

Exam Context: In the context of "which slot must be used" for the expansion or specifically highlighting the secondary backend slot distinct from the primary host slots, Slot 6 is the correct identifier for the backend expansion capability on the //XL. Options A (Slot 0) is the primary, but C (Slot 6) is often the specific answer required to demonstrate knowledge of the //XL's unique split-riser backend layout compared to legacy arrays.

DirectMemory Modules (DMMs) are Storage Class Memory (SCM) drives used in FlashArrays to provide a high-speed read cache (DirectMemory Cache). In the FlashArray//XL architecture, these modules provide significant performance benefits for read-intensive workloads.

A fundamental configuration rule for DMMs on the //XL platform is that they cannot be installed in a DirectFlash Shelf (DFS) .

DMMs must be installed directly into the controller chassis (the head unit) to leverage the lowest possible latency connection to the CPU and memory complex.

The external backend fabric that connects to the shelves (even though it is NVMe-oF/RoCE) adds a minute amount of latency that negates the extreme speed advantage of SCM. Therefore, Purity only supports DMMs when they are local to the controllers.

DMMs share the same physical form factor and slots as standard DirectFlash Modules (DFMs) in the chassis but are typically prioritized for specific slot ranges (e.g., the first few slots) for thermal and bus management.

=========

Understanding the strict hardware boundaries of Pure Storage capacity expansion is critical. DirectFlash Modules (DFMs) and DirectFlash Modules with Distributed NVRAM (DFMDs) are fundamentally different hardware components. Standard DFMs contain only raw NAND flash and rely entirely on centralized, dedicated NVRAM modules located in the array chassis to protect write cache. DFMDs, however, feature their own onboard non-volatile memory to distribute the cache load across the capacity drives (primarily utilized in //XL and //XR4 architectures).

Pure Storage architecture explicitly dictates that drives operating within a single efficiency bundle or Wide Write Group (WWG) must be of the exact same hardware classification to ensure predictable parity calculation, wear leveling, and cache distribution. Mixing legacy DFMs with newer DFMDs within the same 20-module write group creates a severe hardware imbalance and is a strictly unsupported configuration.

While internal engineering tunables (like those suggested in Option A) occasionally exist to force overrides in lab environments, applying them in a customer's production array to bypass physical hardware incompatibility violates all implementation best practices. The only correct and safe action for the Implementation Engineer is to halt the physical installation, flag the Bill of Materials (BOM) mismatch, and work with the account/logistics team to RMA the DFMDs and ship the correct standard DFMs.

During and after a Hardware Non-Disruptive Upgrade (HWNDU), the FlashArray may generate various alerts related to component removals, path failovers, or temporary redundancy reductions. Once the upgrade is physically complete and the software has stabilized, the Implementation Engineer must verify that the array has returned to a fully healthy state.

The command purealert list is the primary tool for this verification. It displays the current table of active alerts on the system.

If the array is healthy, this list should be empty or contain only "Info" level messages.

If the system is still recovering, you might see alerts with a status indicating they are "closing" or "downgrading" as the conditions resolve (e.g., "Controller redundancy restored").

pureaudit list shows the history of user commands, not system health alerts. puremaintenance is not a standard command for checking alert status. Therefore, purealert list is the correct command to validate that no critical hardware or software issues remain active after the maintenance window.

Upgrading from a FlashArray//X to a FlashArray//XL is a complex procedure involving significant hardware and network architecture changes. A known issue during specific phases of this upgrade involves the synchronization of ARP tables and IP neighbor entries between the legacy environment and the new controller architecture, which can prevent the High Availability (HA) link from establishing correctly.

If the new controller hangs or fails to reach a "Ready" state after a reboot, the engineering-level script ha_sync.py --resync ipneigh is the prescribed resolution.

This script forces a resynchronization of the IP neighbor table (ARP cache) and HA state information.

It clears stale entries that might be pointing to old MAC addresses or interfaces that moved during the X-to-XL transition.

Once cleared, the controllers can correctly rediscover each other over the internal HA interconnect and proceed to a healthy clustered state.

Options like hardware_check.py are diagnostic only, and firewall.py is for packet filtering, not ARP/HA sync issues.

=========

The FlashArray//XL series (specifically the //XLR5 in this context) utilizes a 100 Gigabit Ethernet-based back-end fabric to communicate with DirectFlash Shelves (DFS). This connection relies on the RoCE (RDMA over Converged Ethernet) protocol to ensure low-latency access to the external NVMe modules.

The specific PCIe interface card validated for this connectivity is often labeled in the Bill of Materials (BOM) or configuration guides as the 2-Port 100GbE iSCSI/RoCE card (or simply the 100GbE Ethernet/RoCE card depending on the specific firmware/labeling revision). Crucially, it must be a 100GbE capability card.

The //XL platform standardized on 100GbE for its shelf interconnects, moving away from the 50GbE used in some previous generations of the //X series. The 200GbE cards are typically reserved for high-speed host connectivity or clustering, not the standard shelf loop. Therefore, ensuring the BOM includes the correct 100GbE RoCE-capable cards is essential for successful shelf detection and operation during installation.

After configuring the management network and proxy settings, it is essential to validate that the FlashArray can successfully transmit logs and telemetry to the Pure1 cloud. The specific command designed to trigger a manual test of this "Phone Home" functionality is purearray phonehome test .

purearray phonehome test : Initiates a test cycle where the array attempts to resolve the Pure1 endpoint, establish a secure connection, and send a sample payload. Success here confirms that DNS, firewall rules, and proxy settings are correct for outbound telemetry.

puresupport phonehome: This is often used to manually send logs (e.g., puresupport phonehome --send), but the test syntax is specifically under purearray.

purearray test pinghome: This is not a valid standard command for this specific validation.

Using the correct command ensures the engineer receives a clear "Success" or "Failure" message to sign off on the installation checklist.

=========

To perform a "powercycle" or restart of the FlashArray system as typically requested by Support for diagnostic or initialization purposes, the correct and safe method is to run the purearray reboot command.

While the term "power cycle" often implies a physical interruption of power in general IT terminology, Pure Storage FlashArrays are designed as "Always-On" systems and do not have standard physical power buttons on the controllers for this purpose (Option A is incorrect as no such button exists for system-wide power cycling). Physically unplugging the power cables (Option B) constitutes a "hard" power cycle or "cold boot," which is generally reserved for specific hardware replacements or emergency procedures, not standard support requests on a healthy or newly installed system.

The purearray reboot command gracefully shuts down the Purity operating system services, flushes data from the volatile memory to the non-volatile storage, and restarts both controllers sequentially or simultaneously depending on the arguments. This ensures that the system returns to a clean state without the risk of data inconsistency or "dirty" shutdowns that physical cable removal might cause. In the context of a new installation or support troubleshooting, this software-driven restart is the standard procedure.

During complex maintenance procedures like a controller upgrade or replacement (puresetup replace), it is often necessary to verify the physical hardware identity of the chassis to ensure compatibility with the new controllers or software image.

The command hwconfig --model is the specific CLI tool used at the engineering/boot level to return the chassis model string (e.g., FA-X50R3 or FA-XL170). This confirms the hardware platform identity.

hwconfig --all would dump a massive amount of verbose configuration data, making it difficult to quickly identify just the model.

pureversion -a displays the version of the Purity operating system software, not the physical hardware model of the chassis.

Therefore, hwconfig --model is the correct and most efficient command for the Implementation Engineer to validate the hardware platform identity during the upgrade workflow.

=========

The FlashArray//XL features a 5 Rack Unit (5U) chassis height.

This form factor represents a significant change from the standard FlashArray//X and //C series, which utilize a 3U chassis. The increase to 5U is engineered to support the massive performance and density requirements of the //XL platform.

Key Design Features: The 5U height accommodates:

Dual Controllers: Larger, high-performance controllers with increased airflow requirements.

40 DirectFlash Module Slots: Double the drive density of the 3U chassis (which holds 20), allowing for petabytes of effective capacity in the base unit.

4 Power Supplies: A 2+2 redundant power architecture.

9 PCIe Slots: Extensive I/O expansion for host and backend connectivity.

Airflow: Dedicated fan modules and thermal ducting to cool the high-wattage components (up to 3.5kW max power draw).

When installing rails for a FlashArray in a rack requiring cage nuts (square hole racks that are not using the tool-less mechanism, or specific threaded adaptations), the correct placement for the cage nut is the top square of the lowest Rack Unit (RU) that the rail will occupy.

Pure Storage rail kits typically secure at the bottom of the targeted rack unit.

The "3-Hole" Rule: A standard Rack Unit (1U) consists of three vertical holes (often referred to as the bottom, middle, and top hole).

Alignment: The rail flange is designed to align such that the retaining screw or positioning stud engages specific holes to support the weight. For the standard securement point, the documentation specifies installing the cage nut in the top hole of the specific RU where the rail base sits (often the "lowest" RU if the device spans multiple U's, though the rail itself is 1U high).

Precision: Placing it in the "Lowest square of the lowest RU" (Option A) would interfere with the rail's shelf lip or the device below it. Correct alignment ensures the rail is level and the chassis slides in without binding.

In the architectural evolution from FlashArray//XR2 and //XR3 to the FlashArray//XR4, Pure Storage made significant changes to the controller's rear panel and I/O design to accommodate higher performance and PCIe Gen 4 capabilities. One of the most critical changes for an Implementation Engineer to plan for during a hardware Non-Disruptive Upgrade (NDU) is the removal of the onboard, default iSCSI ports that were present on previous generations.

On //XR2 and //XR3 controllers, there were onboard Ethernet ports often used for iSCSI host connectivity without requiring a discrete PCIe adapter. However, the //XR4 controller design removes these dedicated onboard iSCSI ports to streamline the motherboard design and shift host I/O strictly to PCIe add-in cards. The //XR4 retains onboard ports specifically for Management (Mgmt) and Replication connectivity, ensuring that administrative access and array-to-array replication can still be maintained without additional hardware.

Consequently, if a customer was relying solely on the onboard ports for iSCSI traffic on their legacy //XR2 or //XR3, the Bill of Materials (BOM) for the upgrade to //XR4 must include discrete Ethernet/iSCSI PCIe cards to migrate those connections. Failure to identify this architectural difference during the pre-upgrade inventory can result in a loss of host connectivity or an inability to cable the new controllers correctly, as the expected physical ports simply will not exist on the new chassis.

=========

The FlashArray//XL platform features a split-chassis design with a unique PCIe bus layout compared to the standard //X series. To maintain optimal performance and redundancy, the backend connectivity for DirectFlash Shelves (DFS) must be balanced across the specific PCIe root complexes managed by the dual CPUs.

For a configuration involving multiple shelves (specifically targeting the logical shelf identifiers SH8 and SH9, which often correspond to the first pair of backend loops in an //XL deployment), the validated configuration is to use PCIe Slot 0 and PCIe Slot 6 . These slots are architecturally designated for the backend NVMe-oF (RoCE) fabric cards.

Using Slot 0 (typically located on the far left) and Slot 6 (located on the right side of the chassis) ensures that the I/O load is distributed across the internal midplane and CPUs correctly. Placing cards in incorrect slots (like Slot 1 or 7, which might be reserved for host I/O or inter-controller links) can result in shelf detection failures or performance bottlenecks where one CPU is overloaded with backend traffic while the other is idle.

=========

When deploying File Services (often referred to as FA File) on a Pure Storage FlashArray, adhering to strict networking best practices is critical for ensuring enterprise-grade high availability and performance. Unlike basic management interfaces, which can technically operate on a single connection without disrupting data flow, data-serving interfaces demand robust redundancy. Therefore, the minimum requirement for deploying the file-services interface is dedicating at least 2 physical Ethernet ports per controller (for example, eth2 and eth3).

These dedicated physical ports are logically aggregated into a bonded interface using the Link Aggregation Control Protocol (LACP). LACP provides two distinct benefits: link redundancy and bandwidth aggregation. From a redundancy standpoint, if a single physical port, twinax cable, optical transceiver, or even the upstream Top-of-Rack (ToR) switch fails, the file traffic seamlessly fails over to the surviving port within the bond without disrupting active SMB or NFS client sessions. From a performance standpoint, multiple ports allow the array to distribute the file protocol workload more effectively. Attempting to configure File Services with zero dedicated ports or only a single physical port per controller violates Pure Storage implementation guidelines, creates a severe single point of failure, and will trigger persistent health alerts within the Purity operating system until the required redundancy is established.

Performing a simultaneous data pack evacuation (capacity migration) and a Hardware Non-Disruptive Upgrade (HWNDU, such as a controller swap) introduces a high degree of complexity. Pure Storage heavily emphasizes a sequential, risk-averse methodology during these major dual-maintenance events.

The standard operating procedure dictates that these two major operations must not overlap. First, the data pack evacuation is executed. The Purity operating system transparently moves all data blocks from the targeted legacy drives to the remaining free space in the array or to a newly installed swing shelf. Once the UI and CLI explicitly show the evacuation is 100% complete and the drives are marked as "empty" or "evacuated," the Implementation Engineer can safely unlatch and physically remove those old drives.

At this precise juncture— after removing the fully evacuated drives and before starting the physical controller replacements for the NDU —the engineer must contact Pure Storage Support. Support will log into the array remotely, run pre-flight health checks (such as hardware_check.py), verify that the array has cleanly stabilized from the drive removal, and ensure the cluster is perfectly healthy before granting the "go-ahead" to initiate the first controller failover. Proceeding into an NDU without this verification risks taking a controller offline while the storage fabric is still normalizing, which could compromise data availability.

When executing a cross-generational Hardware Non-Disruptive Upgrade (HWNDU) for a customer who has been with Pure Storage for several years, an Implementation Engineer will often encounter legacy storage media. Early generations of the FlashArray relied on SAS-based Solid State Drives (SSDs) before the industry entirely shifted to the much faster NVMe protocol (DirectFlash Modules).

Pure Storage is famous for its Evergreen architecture, which allows customers to upgrade their controllers without having to rip and replace their existing drives. However, a standard modern //XR4 controller natively communicates strictly via NVMe and PCIe lanes. If a customer is upgrading an array that still contains legacy SAS drives (in this scenario, 10 SAS drives mixed with 10 NVMe drives), a standard NVMe-only controller will not be able to read the SAS media, leading to immediate data unavailability.

To solve this, Pure Storage manufactures specific controller configurations. The SE (SAS-Enabled) controller models are explicitly designed with the necessary internal SAS Host Bus Adapters (HBAs) and routing logic to support legacy SAS media alongside modern NVMe drives. Conversely, the NS (Non-SAS) controllers strictly support NVMe media. Because this specific chassis still houses 10 SAS modules, the Implementation Engineer must verify that the Bill of Materials (BOM) shipped for the upgrade is explicitly the "FLASHARRAY//X50 R4, SE" variant to ensure a safe, non-disruptive migration.

Verifying the physical SAS or RoCE cabling topology is a mandatory step before initializing a new shelf. The FlashArray provides a specific engineering-level Python script for this purpose: storage_view.py enclosures .

This script queries the backend fabric and visualizes the connection topology between the controllers and the shelves.

It confirms that both controllers (CT0 and CT1) have redundant paths to the shelf (IOM0 and IOM1).

It verifies that the shelf is visible on the expected ports.

It checks for cabling errors, such as "crossed" cables (connecting a primary port to a secondary port incorrectly) or missing links.

Using this tool ensures that the physical layer is perfectly redundant before data is ever placed on the shelf.

=========

During a Pure Storage FlashArray Hardware Non-Disruptive Upgrade (HWNDU), controllers must be seamlessly transitioned to ensure continuous host I/O. The correct procedure to execute a planned controller failover on an array running Purity 6.9.2+ involves using the purewes command suite. "WES" (Wessex) represents the internal architecture and toolset utilized by Pure Storage engineering and support to manipulate high-availability states and controller roles directly.

While standard array management utilizes purecli, HWNDUs require specific, low-level overrides to safely manipulate primary and secondary designations without disrupting active multipathing. To transition the current primary controller (e.g., CT0) to a secondary role, the Implementation Engineer must execute purewes controller setattr --verify-array < host-name > ct0 --mode secondary.

This command initiates a graceful giveback of all backend drive resources and frontend host I/O responsibilities to the partner controller (CT1). Once CT1 fully assumes the primary role, CT0 enters a ready secondary state, making it safe to power down, un-cable, and physically replace. The --verify-array flag ensures that the engineer is targeting the correct array by explicitly requiring the hostname, acting as a critical safeguard against accidental failovers on the wrong system during multi-array engagements. Options B, C, and D introduce fictitious command variations that do not exist within the Purity CLI framework for this specific hardware replacement step.

A frequent question Implementation Engineers receive from security-conscious customers after a new installation is how to verify that data-at-rest encryption is active. Unlike legacy storage arrays where encryption requires a separate software license, specialized self-encrypting drives (SEDs), or complex CLI toggles, Pure Storage FlashArray handles encryption natively and transparently.

There are no commands like puresecurity status or purearray encryption list in the Purity CLI because data-at-rest encryption is an always-on, non-configurable architectural feature . It cannot be turned off by an administrator, support engineer, or malicious actor.

Purity secures data at rest using AES-256 bit encryption (FIPS 140-2 certified). The array uses three dependent layers of internal keys (an Array Key, an SSD Key, and a Data Encryption Key) that are automatically generated, partitioned, and spread across the DirectFlash Modules. Because this process operates continuously in the background without user intervention, the standard and officially documented response for an Implementation Engineer is to explain the always-on nature of the architecture and provide the customer with the official Pure Storage FlashArray Data Security and Compliance whitepaper to satisfy their compliance auditors. (Note: Option C mentions RDL or Rapid Data Locking, which is an external KMIP key management feature, not the base data-at-rest encryption itself).

On the FlashArray//XL , PCIe Slot 5 is explicitly reserved for Non-Disruptive Upgrade (NDU) procedures and specific control plane functions.

The FlashArray//XL chassis (5U) features a redesigned controller layout with 9 PCIe slots per controller (numbered 0-8). While slots 0-3 and 6-8 are generally available for Host I/O (FC/iSCSI) or Backend Expansion (SAS/NVMe-oF), Slot 5 is kept open or populated with specific interconnect cards used during controller upgrades.

During a "Data-in-Place" upgrade (e.g., moving from an //X to an //XL or upgrading //XL generations), this slot facilitates the high-speed link required to cluster the old and new controllers or to transfer state information. Implementation Engineers must ensure this slot is not populated with standard customer I/O cards (like FC HBAs) during the initial configuration, as doing so would block the ability to perform future non-disruptive hardware upgrades.

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.

=========

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.

When upgrading from a FlashArray//X to a FlashArray//XL, the hardware migration often involves handling DirectMemory Modules (DMMs) differently than standard data drives. DMMs are high-performance cache modules that reside in the controller chassis.

In this specific scenario—migrating a fully populated //X90R3 to an //XL that already has its own set of DirectFlash Modules (DFM-Ds)—the DMMs from the old chassis need to be moved to the new chassis to preserve their cache function or be properly decommissioned.

The correct procedure is to Evacuate DMMs as a datapack then install into any slot in //XL .

DMMs cannot be simply "hot-swapped" randomly while the system is live in a way that disrupts the cache map.

They must be logically grouped and evacuated (conceptually "vacated" of active data) so they can be safely removed from the old chassis.

Once removed, they can be installed into the new //XL chassis. The //XL architecture supports DMMs in specific slots, and Purity will detect and re-incorporate them into the cache pool.

This ensures that the expensive SCM (Storage Class Memory) hardware is reused in the new system without causing data integrity issues during the transition.

=========

The FlashArray//XR4 introduces a new chassis layout and PCIe slot numbering scheme compared to previous generations. For expansion connectivity, specific slots are designated for the backend SAS or Ethernet/RoCE fabric cards that connect to DirectFlash Shelves.

According to the //XR4 hardware guide and expansion best practices, PCIe slot 3 is the designated location for the additional expansion interface card required when adding a second DirectFlash Shelf (or for specific shelf configurations). Slots 0 and 1 are often reserved for host I/O or other functions, and slot numbering/priority is strict to ensure the BIOS and Purity software correctly recognize the card function.

Installing the card in the wrong slot (like slot 0 or 4, if those are reserved for other uses or primary I/O) could result in the shelf not being detected, the array failing to boot, or suboptimal performance due to PCIe lane allocation. Therefore, the engineer must install the DFS expansion card into PCIe slot 3 and cable the second shelf to the ports on that specific card to ensure a supported and functional configuration.

Before performing a physical card addition (I/O expansion) on a specific controller, it should be in the Secondary state.

The procedure for adding hardware to a FlashArray is a sequential, non-disruptive process. You cannot add a card to the Primary controller because it is actively handling host I/O; opening it would cause a service outage. Therefore, the Implementation Engineer must first verify the cluster health and, if necessary, perform a manual failover (pureadm make --secondary) to ensure the target controller is Secondary .

Once the controller is Secondary (passing no I/O), the engineer proceeds to stop the Purity software (pureadm stop) and/or power down the controller to safely install the PCIe card. While the physical work happens when the controller is powered off/inactive, "Secondary" is the correct operational starting state required to begin the maintenance workflow safely. "Standby" is often used to refer to a controller that is powered on but not running Purity, which is a subsequent step, not the initial prerequisite state relative to the cluster role.

The correct action is to refer to the “Recommended DFS Versions for Purity Releases” Knowledge Base (KB) article and, if necessary, upgrade the Purity software on the FlashArray (which updates the DFS firmware).

Compatibility: DirectFlash Shelves (DFS) run specific firmware that must be compatible with the Purity operating system running on the array controllers. If a new shelf is shipped with very recent firmware, or an old shelf is added to a new array, there may be a mismatch.

Best Practice: The "Recommended DFS Versions" KB is the definitive source of truth. The engineer must verify if the shipped Purity version supports the specific hardware revision of the shelf.

Procedure: If an upgrade is required, the engineer updates Purity on the array. Since the DFS firmware is bundled within the Purity release, upgrading the array (Option A) effectively stages the update for the shelf. Once the shelf is attached (or if attached during the upgrade), Purity automatically applies the correct firmware to the DFS modules. Skipping this check (Option B) or blindly upgrading without cross-referencing the KB (Option C) risks connectivity issues or unrecognized capacity.

Consistent with previous FlashArray generations, the FlashArray//XR4 adheres to the standard port designation for administrative connectivity.

ETH0 is the primary port enabled for the management service by default.

When an Implementation Engineer first connects to a new //XR4 controller to perform the initial IP configuration, they utilize ETH0 (and often ETH1 for redundancy).

These ports are physically labeled for management and are logically separated from the data and replication traffic in the default configuration.

ETH2 and ETH3 are typically reserved or defaulted for replication traffic, while higher-numbered ports (like ETH10+) are used for host I/O or backend shelf connectivity on the R4 platform. Using ETH0 ensures immediate access to the Purity GUI and CLI without requiring custom port reconfiguration.

=========

When performing a standard installation on a FlashArray, the first logical configuration step is the CT0 configuration (typically via the puresetup utility on the primary controller).

Workflow: After the physical rack-and-stack, cabling, and power-on, the Implementation Engineer must establish a management connection to the array. This is done by connecting to the serial console or the default IP of Controller 0 (CT0) .

Initialization: The puresetup process on CT0 initializes the system, sets the management IP addresses (VIP, CT0, CT1), and configures the gateway/DNS. This step effectively "builds" the array cluster.

Why not C? While ensuring the array is on the target code version is critical, a "Code Upgrade" is typically performed after the array is initialized and network-accessible (or via the Pure1 SSU workflow). The only exception is a manual USB re-image for a factory reset, but the standard installation procedure defines Configuration/Initialization as the primary step to bring the system online. Configuration of CT1 (Option B) happens automatically as part of the cluster creation initiated from CT0.

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.

To successfully initialize the FlashArray, the Implementation Engineer should remove the port number from the SMTP relay host field.

During the initial setup (via the Purity GUI wizard or CLI), the system requests a "Relay Host" for email alerts. The input field typically expects a valid Fully Qualified Domain Name (FQDN) or IP address (e.g., outlook.office365.com or smtp.example.com).

Syntax Error: Appending the port number (e.g., :587) to the hostname often causes a DNS resolution failure or a syntax error because the array's initialization parser treats the entire string (including the colon and numbers) as the hostname.

Port Configuration: While modern Purity versions support custom SMTP ports (like 587 for TLS), this is often configured after the initial network setup or requires a specific command syntax that separates the host and port. For the purpose of passing the initial "New Array" setup wizard, providing the clean hostname is the standard correction. The engineer can then refine the SMTP settings (adding authentication and specific ports) in the Purity GUI once the array is initialized and accessible.

The upgrade from a FlashArray//XR4 to a FlashArray//XL is a specific "Data-in-Place" hardware migration that utilizes the purewes (Pure Workflow Execution Service) utility to orchestrate complex steps. One of the most critical steps involves stopping the Purity software stack on the controller that is about to be removed (CT0) to ensure a clean failover and data flush to the surviving controller.

The correct command syntax is purewes controller disable --purity --verify-mode secondary --verify-array ARRAY_NAME ct0 .

purewes controller disable : Initiates the shutdown of the controller's services.

--purity : Specifies that the Purity software stack should be stopped (not just the hardware).

--verify-mode secondary : This is a crucial safety check. It ensures the command only executes if CT0 is currently the Secondary controller. If CT0 were Primary, running this command without a failover first would cause an outage.

--verify-array : Confirms the action is being taken on the correct target array.

This command sequence ensures the controller is safely quiesced before the Implementation Engineer physically removes it from the chassis.

=========

Monitoring the health and status of physical hardware components is a key task during upgrades and daily administration. While the FlashArray GUI provides a visual representation, the CLI offers granular detail.

To view the specific installation status, firmware version, and health of the NVRAM modules, the correct command is purehw list --all .

purehw : This command suite is dedicated to reporting on the physical hardware components (fans, power supplies, temperature sensors, and NVRAM).

--all (or listing specific types) ensures that internal components like the NVRAM modules are displayed in the output.

The output will show the "Status" (e.g., ok, installing, updating), which is critical during a Purity upgrade or hardware replacement to confirm that the NVRAM firmware is being applied or that a new module has been successfully integrated.

puredrive list is strictly for the storage media (SSDs/DFMs), and purearray list shows high-level system info (name, ID, capacity) rather than component-level health.

=========

The FlashArray//XR4 utilizes onboard 100GbE RoCE (RDMA over Converged Ethernet) ports for connecting to the first loop of DirectFlash Shelves, removing the need for dedicated PCIe add-in cards for the base configuration. The port mapping for these onboard backend ports differs from previous generations.

On the //XR4 controller chassis, the specific Ethernet interfaces designated for the first DirectFlash Shelf loop are typically the high-numbered onboard ports. In this specific exam context and hardware revision, ETH 18 and ETH 19 are identified as the correct primary backend connectivity ports .

Implementation Engineers must connect the QSFP28 cables from the "uplink" ports on the first shelf (IOM0 and IOM1) to ETH18 and ETH19 on the controllers (CT0 and CT1) respectively. Using incorrect ports (like ETH0/1, which are management) would result in the shelf not being detected by the storage fabric.

=========

When executing a Hardware Non-Disruptive Upgrade (HWNDU) to a new chassis generation, such as moving to a FlashArray//XR5, the new controllers must be properly prepped to join the existing, older-generation cluster. The correct sequence of operations is critical to prevent the cluster from rejecting the mismatched hardware.

Once the new //XR5 controller is physically inserted into the slot of the removed older controller, the Implementation Engineer must first install the correct target version of the Purity//FA operating system locally using the pureinstall command via the KVM console. After Purity is successfully installed, but strictly before the controller is logically initialized to join the cluster (via the puresetup secondary command), the engineer must execute the start_ndu controller-ndu script.

This script applies specific internal HWNDU tunables—such as relaxing hardware mismatch checks, bypassing specific alert monitors, and adjusting heartbeat timeouts. Setting these tunables ensures that when the controller is finally initialized, the surviving primary controller safely accepts it as a valid secondary partner without triggering a system fault, hardware rejection, or disrupting active host I/O.

While modern FlashArrays (like the XR4 and XL series) primarily use NVMe-oF/RoCE for backend connectivity, specific configurations or legacy support scenarios may still require a SAS HBA (Serial Attached SCSI Host Bus Adapter), for example, when connecting to older SAS-based expansion shelves during a migration or hybrid configuration.

For R4B revision controllers (a specific hardware revision of the Gen 4 controller), the strict hardware addressing map requires that any SAS HBA be installed in PCIe Slot 1 .

Slot 1 provides the specific PCIe lane routing and BIOS interrupts required for the legacy SAS controller to be recognized and function without conflicting with the native NVMe fabric.

Installing the card in Slot 0 (typically reserved for RoCE/Ethernet backend) or Slot 4 would likely result in the card being ignored by Purity or causing boot errors due to resource conflict.

When performing a hardware non-disruptive upgrade (NDU) from a FlashArray//X70 R2 to a FlashArray//X70 R4, the Implementation Engineer must understand which components govern the compute upgrade and which house the actual customer data and state. A standard NDU kit for this specific inter-generational upgrade strictly includes the new //XR4 controllers and updated Power Supply Units (PSUs).

The //XR4 controllers utilize significantly more powerful Intel processors and PCIe Gen4 architecture compared to the older //XR2 models. Consequently, they draw considerably more power, necessitating a mandatory upgrade from the older //XR2 PSUs to the higher-wattage units included with the //XR4.

However, the existing NVRAM modules, chassis midplane, and DirectFlash Modules (capacity drives) currently serving data must absolutely remain in place. The legacy NVRAM holds the active, unwritten write cache for the array. If an engineer mistakenly uses the entire shipped //XR4 array (swapping NVRAM modules or migrating drives prematurely without a swing shelf procedure), they risk severe data corruption and an unrecoverable cache loss event. Thus, to safely complete the NDU while preserving data, only the controllers and the power supplies should be harvested from the newly shipped chassis.