FlashArray-Implementation-Specialist Pure Certified FlashArray Implementation Specialist (FAIS) Exam Questions and Answers

Data evacuation from a shelf is a sensitive background process where data is migrated off specific physical media to free it for removal. While the purearray evacuate command initiates the data movement, the finalization of the process—specifically the logical removal of the shelf object from the system configuration to allow for safe physical disconnection—often requires engineering-level commands or verification.

Therefore, before Pure Storage Support can log in to run these specific completion scripts or verification checks, the Implementation Engineer must Enable Remote Assist (RA) .

Remote Assist creates a secure, outbound SSH tunnel that allows Support to access the array remotely.

Without RA enabled, Support cannot connect to the array to execute the necessary puredrive or internal maintenance commands to mark the shelf as "vacated" and safe to unplug.

Powering off the shelf (Option B) before this step could result in data loss or an array outage if the system still believes data resides there.

=========

A "4X Module" kit is specifically designed to widen an existing write group (RAID set).

Write Group Geometry: In standard FlashArray//X configurations, DirectFlash Modules (DFMs) operate in "Write Groups" (typically 10 modules wide for a standard data pack). However, to offer more flexible entry points or capacity expansion options, Pure Storage allows configurations that start with smaller write groups (e.g., 6 modules).

Widening: When a customer wants to expand capacity or performance on these smaller configurations without adding a full new 10-pack, they can purchase a widening kit (in this case, 4 modules).

Process: The Implementation Engineer installs these 4 modules into the empty slots. The Purity operating system then logically integrates these new drives into the existing narrow write group, "widening" it to the standard width (e.g., 6 + 4 = 10). This operation redistributes parity and data across the full set of 10 drives, improving performance and efficiency.

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.

=========

Capacity expansion on a Pure Storage FlashArray is a highly controlled, safe process. When an Implementation Engineer physically unboxes and inserts a new data pack (a group of DirectFlash Modules) into the available drive bays of a chassis or a DirectFlash Shelf, the Purity operating system detects the hardware instantly. However, it does not automatically wipe the drives and assimilate them into the global storage pool.

Instead, the newly inserted modules are placed into a safe, quarantined state known as "unadmitted." This intentional design choice prevents catastrophic data loss in the event that an engineer accidentally inserts a drive containing live data from another system, or inserts drives before the customer is financially or operationally ready to activate the new capacity.

To officially claim the drives, integrate them into the system's Wide Write Groups (WWGs), and initiate the background parity redistribution process, the Implementation Engineer must explicitly authorize their use. This is accomplished by running the puredrive admit command. The engineer can either specify the exact drives (e.g., puredrive admit CH0.BAY10 CH0.BAY11...) or use a global flag like puredrive admit --all if all unadmitted drives are ready for ingestion. Once admitted, the drives transition to a "healthy" state, and the array's total usable capacity increases seamlessly without any host disruption.

When performing a Hardware Non-Disruptive Upgrade (HWNDU) to the FlashArray//XR4 generation, Implementation Engineers must be acutely aware of power constraints. The //XR4 architecture introduced massive performance upgrades, leveraging PCIe Gen4 and newer Intel processors. Consequently, standard //XR4 arrays strictly require high-line power (200V-240V) to operate.

However, to accommodate entry-level customers in smaller datacenters or edge locations, Pure Storage released the //X10R4-LL and //X20R4-LL ("Low-Line") models. These specific models are equipped with power supplies designed to run on standard 120V circuits.

The critical tradeoff for using 120V low-line power is a strict physical limitation on available wattage. Because 120V circuits cannot deliver the peak wattage required to spin up a fully populated chassis while driving the Gen4 compute overhead, the //X10R4-LL and //X20R4-LL strictly support a maximum of 10 capacity drives (a single data pack) in the chassis.

If an Implementation Engineer is upgrading an older //X20R3 that had 20 drives (which was previously supported on low-line power due to lower CPU overheads) to an //X20R4-LL, the pre-flight power supply validation script will intentionally fail. The array detects that the 120V supplies cannot safely support the 20 physical drives currently seated in the chassis. To resolve this, the customer must either provide 208V+ high-line power and use standard R4 power supplies, or migrate the excess capacity to an external DirectFlash Shelf (which has its own independent power).

The FlashArray//XL utilizes a massive 5U chassis with a highly specific PCIe slot population architecture optimized for NVMe-oF (RDMA over Converged Ethernet - RoCE) backend connectivity. According to the FlashArray//XL Port Usage and Definitions hardware matrix, an //XL configuration supports up to two 2-port 100GbE cards explicitly dedicated to NVMe DirectFlash Shelf (DFS) connectivity.

The standard implementation procedure mandates that the primary shelf connectivity card must be installed in PCIe Slot 0 (the default slot). However, if an Implementation Engineer arrives onsite and discovers that Slot 0 is already legitimately occupied by another critical I/O card, the officially supported secondary/alternate slot for routing the backend DFS loop is PCIe Slot 6 .

Slot 5 and Slot 8 are strictly reserved for frontend host I/O connectivity (such as 32G/64G Fibre Channel HBAs). By installing the 100GbE RoCE backend expansion card into Slot 6, the engineer ensures optimal NUMA node alignment, prevents frontend/backend traffic collisions, and passes the array's mandatory pre-flight hardware_check.py validation script, allowing the new DirectFlash Shelf to initialize seamlessly.

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.

=========

To reduce SafeMode protections (such as shortening the retention period or disabling the eradication timer), two authorized SafeMode approvers must authenticate and approve the request via Pure1 step-up authentication .

SafeMode is a ransomware protection feature designed to prevent the accidental or malicious deletion of snapshots. Because reducing these protections weakens the array's security posture, Pure Storage enforces a strict "Ratchet" authorization process.

The Process: Unlike standard support requests, a single admin or local user cannot authorize this change (making Option C incorrect). The customer must have previously designated specific individuals as "SafeMode Approvers" in their Pure1 portal.

Authorization: When a request to weaken the policy is made, Pure Support triggers a verification workflow. Two of these designated approvers must log into Pure1 and perform a secondary authentication (often involving a PIN or TOTP) to explicitly "sign off" on the reduction. This "two-person rule" ensures that a compromised credential or a rogue insider cannot unilaterally expose the organization's backup data to destruction.

The correct procedure is to move the 20TB chassis Data Pack (DP) to the external shelf (SH0) to free up a chassis slot for the new high-capacity pack.

Capacity Analysis: The array has ~52TB total raw capacity (20+10+22) and is 83% full (~43TB used).

Constraint: You cannot simply "evac" the chassis drives (Option A) because the remaining capacity (22TB in the shelf) is insufficient to hold the 43TB of data. Similarly, evacuating the shelf first (Option C) leaves only 30TB in the chassis, which is also insufficient.

The Solution (Option B):

Relocate: The engineer physically moves the 20TB pack from the Chassis (Slot 0) to the empty slot in Shelf 0 (SH0). This is a supported non-disruptive operation (assuming compatible shelf/pack types).

Install: This clears Chassis Slot 0, allowing the installation of the massive 91TB Data Pack .

Consolidate: The system now has huge capacity (10+20+22+91). Purity can safely evacuate the old 10TB pack (Chassis) and the external shelf packs (20+22) into the new 91TB internal capacity.

Final State: The array ends up with the single 91TB pack in the chassis, meeting the "X50R2-91/0" target configuration.

When adding external capacity to a Pure Storage FlashArray via a DirectFlash Shelf (DFS), Implementation Engineers must adhere to strict, high-speed networking port assignments to ensure maximum backend throughput. Unlike older Fibre Channel or basic SAS expansion shelves that use dedicated SAS cabling, a modern DFS relies on massive 50GbE or 100GbE bandwidth using the NVMe-oF (RDMA over Converged Ethernet - RoCE) protocol to maintain NVMe-level speeds across the external fabric.

According to the official FlashArray//XR4 Port Usage and Definitions hardware matrix, the onboard 100GbE RoCE ports explicitly dedicated to the first loop of a DirectFlash Shelf are physically located on the controllers and identified within the Purity operating system as ETH 18 and ETH 19 .

These specific ports are hardware-optimized to handle the extreme backend IOPS generated by the external DirectFlash Modules communicating back to the primary chassis. Utilizing standard 1GbE/10GbE management/replication ports (such as ETH 0/1) or other generic PCIe Ethernet host interfaces (such as ETH 10/11) is unsupported for the primary DFS backend loop. Plugging the shelf into the wrong ports will result in cabling validation failures during the hardware_check.py execution, preventing the new capacity from being recognized by the array.

During a complex cross-generational Hardware Non-Disruptive Upgrade (HWNDU) from a FlashArray//XR4 to a FlashArray//XL, the Implementation Engineer must carefully orchestrate the shutdown and removal of the legacy compute nodes. Before physically unlatching and removing the CT0 controller, the Purity//FA operating system processes running on that specific node must be gracefully halted.

Because standard user commands do not allow for this level of low-level service manipulation, the engineer must utilize the purewes (Wessex) command-line suite. Wessex is the internal engineering toolkit used to override high-availability states during hardware replacements.

The correct command to execute is purewes controller disable --purity --verify-mode secondary --verify-array < ARRAY_NAME > ct0 .

This command contains several critical safety mechanisms. The --purity flag specifies that the script should shut down the Purity storage processes rather than just network interfaces. The --verify-mode secondary flag is a mandatory safeguard; it checks the cluster state to guarantee that CT0 has already successfully failed over its active host I/O responsibilities to CT1. If CT0 is still the primary controller, the command will intentionally fail to prevent an accidental storage outage. Finally, --verify-array ensures the engineer is executing this disruptive command on the correct physical array, which is crucial when multiple SSH sessions are open in a busy datacenter.

Pure Storage DirectFlash Shelves (DFS) are designed with high-efficiency, enterprise-grade power supply units (PSUs). These PSUs are "auto-ranging," meaning they can accept a wide range of input voltages, typically from roughly 90V to 264V AC.

While data centers often prefer 208V-240V power sources for better efficiency (less heat loss and lower amperage draw for the same wattage), the hardware is fully validated and supported to operate on standard 110V/120V circuits . There is no "temporary only" restriction or hardware lockout that prevents operation on 120V.

Therefore, if the customer's high-voltage PDUs are full, the Implementation Engineer can safely connect the DirectFlash Shelf to the available 120V outlets. The shelf will function normally, provided the circuit has sufficient amperage capacity (amps) to handle the slightly higher current draw that results from using a lower voltage. This configuration is supported for the entire service life of the shelf.

=========

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.

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.

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.

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.

=========

The pureinstall command is a low-level Purity operating system utility used strictly by Implementation Engineers and Pure Storage Support to install or upgrade the Purity//FA image on a controller's boot drive before the array is logically initialized.

When an Implementation Engineer unpacks a new FlashArray, the controllers may ship with a factory default version of Purity. If the customer's deployment requires a specific target version of Purity//FA (e.g., to match a fleet standard or enable a new feature), the engineer must boot into the controller via the local KVM/Serial connection and log in as the puresetup user. From here, they mount a USB drive containing the .ppkg firmware file and execute pureinstall purity- < version > .ppkg.

This process writes the new Purity operating system to the alternate boot partition. After executing pureinstall and rebooting the controller to boot from the new partition, the engineer then runs the puresetup newarray command (or puresetup secondary on the peer controller) to logically initialize the array, assign management IP addresses, and set the array name. Therefore, pureinstall must always be run prior to initialization.

The Pure Engagement Request (PER) or Implementation Workbook (IWB) is the planning document where customers specify their desired configuration parameters. Validating these parameters against Purity requirements before arriving onsite is a critical step for the Implementation Engineer.

Regarding the array name "123": Array names cannot start with a digit .

Purity naming conventions follow standard DNS hostname RFC guidelines to ensure compatibility with network services and scripts.

While numbers are allowed within the name (e.g., array123), the first character must be a letter.

A name composed entirely of numbers (like "123") or starting with a number (like "1array") can cause ambiguity for parsers that might mistake the name for an IP address, a specific ID, or an integer value in scripts.

The engineer must flag this in the PER and request the customer provide a compliant name (e.g., flasharray-123) to avoid errors during the puresetup initialization process.

For the FlashArray//X50 R2 and R3 models, the default Fibre Channel (FC) configuration utilizes a 4-port PCIe Fibre Channel card installed in Slot 0 .

The hardware architecture of the FlashArray//X series differentiates slot usage based on the model controller chassis.

FlashArray//X10 and //X20: These lower-end models utilize Slot 2 for host connectivity (Fibre Channel or iSCSI) because Slots 0 and 1 are typically reserved or occupied by onboard controllers/mezzanine cards. The standard card for these models is often a 2-port card.

FlashArray//X50, //X70, and //X90: These mid-to-high-range models feature a different PCIe bus layout. Slot 0 is the primary designated slot for Host I/O connectivity. To support the higher performance capabilities and port density requirements of the X50, Pure Storage defaults to 4-port FC cards (typically 16Gb or 32Gb).

Therefore, identifying the model number is crucial. Since the question specifies the X50 (R2/R3), the correct placement is Slot 0, and the correct card type is the 4-port model. Option A is incorrect because the 2-port card is not the standard default for the performance-tier X50. Option B describes the configuration for an X20, not an X50.

This scenario describes a physical layer mismatch between the FlashArray optics and the customer's switch infrastructure.

The PER (planning document) specified 10 Gb/s , so the Implementation Engineer likely installed 10 Gb SFP+ transceivers into the array.

The SAN Switch is operating at 40 Gb/s (likely using QSFP+ ports).

You cannot simply "force negotiate" a 10Gb SFP+ optic to run at 40Gb/s, nor can you plug a 10Gb SFP+ directly into a 40Gb QSFP+ port without specific breakout cables or QSA adapters that match the signaling. The physical transceivers themselves are incompatible with the link speed required by the switch.

To resolve this, the Implementation Engineer must replace the transceivers with the appropriate type .

If the switch is 40Gb native, the array needs 40Gb (QSFP+) optics (if supported on that slot).

Alternatively, if the customer intends to use 10Gb, they must provide 10Gb ports on their switch side.

Given the prompt implies the SAN is 40Gb, the 10Gb optics in the array are the incorrect hardware for that link.

=========

When deploying File Services (often referred to as FA File) on a unified Pure Storage FlashArray, the system must integrate with the customer's existing identity management infrastructure, most commonly Active Directory (AD). Joining the AD domain allows the array to authenticate users seamlessly for SMB and NFS file shares.

During the configuration of FA File, the Implementation Engineer creates a dedicated Virtual Network Interface (VIF), which handles all the high-throughput, frontend client data traffic (the file reads and writes). However, control plane traffic behaves differently.

According to the official Pure Storage File Server Creation Wizard documentation, by default, FlashArray uses the management Ethernet port (management) for DNS communication and reaching domain controllers. The Purity operating system inherently routes LDAP queries, Kerberos authentication handshakes, and DNS hostname resolutions out of eth0 or eth1.

If the customer's network architecture is heavily segmented—meaning the management subnet is completely isolated and cannot route traffic to the Active Directory subnet—the Implementation Engineer must explicitly override this default behavior in the File Services configuration wizard by selecting the newly created File VIF as the "Source Network Interface" for DNS/AD traffic. Otherwise, the default remains the management interface.

When executing an intra-series hardware upgrade or migrating an older FlashArray environment to a modern R4 or R4B controller architecture, Implementation Engineers often encounter mixed-generation hardware. While the modern //XR4 and //CR4 series natively utilize NVMe-oF (RoCE) for their backend DirectFlash Shelf (DFS) loops, customers upgrading from older array generations may still have legacy SAS-based expansion shelves that hold critical production data.

To support the migration or continued use of these older SAS shelves, a dedicated SAS Host Bus Adapter (HBA) must be physically installed into the new R4B controllers. Because the R4B chassis utilizes a highly specific PCIe Gen4/Gen5 lane mapping to maximize frontend and backend throughput, expansion cards cannot be placed arbitrarily.

According to the official Pure Storage hardware configuration matrix for R4B controllers, the designated and only supported location for the backend SAS HBA is PCIe slot 0 . Installing the SAS HBA into Slot 0 ensures it interfaces correctly with the Purity operating system's internal topology map, preventing data bottlenecks against the high-speed frontend Fibre Channel or iSCSI host cards (which typically populate Slot 1 and Slot 2). Incorrectly slotting the SAS HBA will cause the hardware_check.py validation script to fail, preventing the new controllers from recognizing the legacy SAS capacity.

When unpacking and installing a new Pure Storage FlashArray controller, the initial configuration—such as assigning management IP addresses, subnet masks, and gateways via the puresetup utility—must be done completely out-of-band. Because the array does not yet have an IP presence on the customer's network, the Implementation Engineer must connect directly to the controller's serial console port using a standard serial-to-USB adapter and terminal emulation software (such as PuTTY, SecureCRT, or Tera Term).

To successfully establish a readable CLI session with the custom Linux microkernel running on the FlashArray controllers, the terminal emulator must be configured with the exact serial communication parameters expected by the array. According to Pure Storage hardware documentation, the mandatory COM port settings are:

Baud Rate (Speed): 115,200

Data Bits: 8

Parity: None (N)

Stop Bits: 1

Flow Control: None

This configuration is universally abbreviated as 115200 8-N-1 . If an engineer attempts to use older standard speeds (like 9600 or 38400 baud) or leaves flow control (like Xon/Xoff or RTS/CTS) enabled, the terminal window will display unreadable, garbled characters (often referred to as "wingdings"), or the keyboard inputs will fail to register entirely, preventing the initialization of the array.

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.

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.

To enable Pure Storage Support to access the FlashArray for diagnostics, upgrades, or troubleshooting, the correct command is purearray remoteassist --connect .

Remote Assist (RA): This feature creates a secure, outbound SSH tunnel from the FlashArray to the Pure Storage support infrastructure. It allows support engineers to log in remotely without requiring the customer to open inbound firewall ports or set up a VPN.

Command Syntax:

purearray remoteassist: Running this command without arguments simply displays the current status of the session (e.g., "connected" or "disconnected") and the port number.

--connect: This is the specific flag (action) required to initiate the tunnel.

Workflow: When an Implementation Engineer is on-site and needs assistance (or is handing over for a remote upgrade), they execute this command. The output will confirm "Remote Assist enabled" and provide a session name/port, which the engineer then communicates to the Support team. The session typically stays active for a set duration (default 24 hours) or until manually disconnected (purearray remoteassist --disconnect).

During a cross-generational Hardware Non-Disruptive Upgrade (HWNDU), such as migrating from a FlashArray//XR3 to an //XR4, the physical network port layout changes significantly. Older controllers often utilized integrated onboard ports (like eth2 and eth3) for Replication or iSCSI. In newer architectures, these services are shifted to dedicated OCP mezzanine cards or PCIe expansion slots, which may enumerate differently within the operating system.

When the Implementation Engineer runs the puresetup script to initialize the newly inserted controller, the software attempts to validate the legacy network configuration against the new physical hardware topology. If it cannot find the exact physical ports that were mapped on the old controller, puresetup will pause and display an interactive warning or error message indicating that certain network interfaces are missing.

Because this mismatch is an expected architectural consequence of the hardware upgrade, the correct procedure is to acknowledge the warning and continue with the setup process . The engineer must allow the controller to finish its base initialization and join the cluster quorum. Once the new controller is online and functioning as a secondary node, the engineer can log into the Purity CLI or GUI and manually use the purenetwork commands to reassign the affected services (e.g., Replication or iSCSI) to the new, correctly enumerated physical ports before proceeding with the controller failover. Stopping the process or attempting to force the script to accept invalid ports will stall the upgrade.

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.

The Purity upgrade process involves two main phases: installing the software image (placing the bits on the boot drive) and then activating it (booting into the new kernel).

After the pureinstall command has successfully unpacked and staged the new Purity version, the changes are not live until the system reboots. In a Non-Disruptive Upgrade (NDU), this is done one controller at a time.

The required step to commit and run the new version is to Reboot the controller .

The pureinstall workflow typically prompts for or automatically initiates this reboot.

The secondary controller reboots first, loads the new Purity version, and rejoins the cluster.

Then, the primary controller fails over services to the updated secondary, reboots, and updates itself.

A full "Reboot the array" (simultaneous reboot) would be disruptive and is not the standard procedure for an NDU. "Logging out" has no effect on the system state.

The FlashArray//XL series has a specific, validated slot population rule for its PCIe cards to ensure optimal performance and thermal management. For a standard Fibre Channel (FC) configuration on a FlashArray//XLR5 , the factory default shipment includes a specific arrangement of host I/O cards and offload engines.

The correct default configuration is:

PCIe Slot 3: 4-Port 32Gb FC card.

PCIe Slot 5: 2-Port 32Gb FC card.

PCIe Slot 6: DirectCompress Accelerator (DCA).

This layout (Option B) adheres to the //XL's architecture where specific slots are prioritized for frontend host I/O (like slots 3 and 5) and others for offload functions or backend connectivity. Implementation Engineers must verify cards are in these exact slots during the visual inspection. If cards are moved to incorrect slots (like slot 1 or 4 for primary FC in this specific config), the array may not boot or may fail to initialize the FC services correctly due to BIOS enumeration orders.

=========

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.

Validating multipath I/O balance is a critical post-configuration step. The FlashArray CLI provides a specific monitoring tool for this purpose under the purehost command suite.

purehost monitor --balance is the correct command.

monitor : This keyword initiates a real-time display of performance metrics (IOPS, bandwidth, latency).

--balance : This flag breaks down the metrics per initiator (per HBA/path) for the specified host(s).

The output allows the engineer to see if I/O is flowing evenly across all paths. If one path shows 0 IOPS while others are active, it indicates a zoning, cabling, or multipathing configuration issue that must be resolved to ensure high availability.

If physical drives need to be relocated within the array (e.g., rebalancing shelves or moving packs to specific slots to match the target configuration) as part of an XFORM (Data-in-Place) upgrade , this task should be completed after the upgrade is completed .

Risk Management: The primary objective during the upgrade window is to successfully transition the controllers and software to the new generation (e.g., SAS to NVMe, or //M to //X) while maintaining data availability. Introducing unnecessary physical changes—like moving drives between slots—during the active controller swap adds variables and risk to the critical path.

Procedure: The standard workflow involves:

Perform the Controller Upgrade (XFORM).

Verify the new system is stable, healthy, and handling I/O correctly.

Post-Upgrade: Once the system is stable, the Implementation Engineer performs the physical drive relocation (if required) to optimize the layout or consolidate shelves. This ensures that if any issues arise from the drive movement, they are isolated from the controller upgrade process, making troubleshooting significantly easier and safer.

DirectFlash Shelves (DFS) connect to the FlashArray controllers using high-speed protocols (typically RoCE - RDMA over Converged Ethernet) that require high-fidelity signal integrity. Due to the high bandwidth (50Gb or 100Gb speeds) and low latency requirements of the NVMe-oF (NVMe over Fabrics) protocol used for backend connectivity, the physical cabling length is strictly limited.

Pure Storage officially supports a maximum cable length of 3 meters for connecting DirectFlash Shelves to the controller or for daisy-chaining shelves (where supported). Cables longer than 3 meters (such as 5m or 7m) introduce signal attenuation and latency that can destabilize the backend fabric, leading to CRC errors, path flapping, or drive disconnections.

Implementation Engineers must ensure that the rack layout allows the shelves to be placed within this 3-meter radius of the controllers. Typically, shelves are racked immediately above or below the controller chassis to minimize cable run distance. Attempting to span across multiple racks using longer, unsupported cables will result in an unsupported configuration and likely immediate I/O errors.

=========

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.

=========

Pure Storage has introduced Self-Service Upgrades (SSU) via the Pure1 Manage portal to provide customers with greater flexibility and control over their maintenance windows.

If a client cannot wait for a scheduled assisted upgrade with a Support Engineer, the validated and supported path is to go through the Self-Service upgrade portal on Pure1 Manage .

This portal performs the same pre-flight health checks (Remote Assist, array health, pathing) that a Support Engineer would perform manually.

Once the checks pass, the customer can schedule and initiate the Purity upgrade directly from the cloud dashboard.

The process is fully automated and monitored by Pure1. This eliminates the wait time for human resource availability while maintaining the safety guardrails of a supported upgrade. Manual USB installs (Option A) or direct CLI downloads (Option B) are generally restricted or not recommended for standard customer workflows without specific support supervision.

To complete the Non-Disruptive Upgrade (NDU) from an //X70R2 to an //X90R3 using a fully shipped array, the Implementation Engineer must extract and use the Controllers and NVRAM modules .

Stateless Architecture: The FlashArray upgrade philosophy allows the chassis and data drives (Data Packs) to remain in place while the compute (controllers) and cache (NVRAM) are swapped.

Component Compatibility:

Controllers: The X90R3 controllers provide the upgraded CPU/performance required.

NVRAM: The NVRAM modules (located in the chassis front or rear slots depending on generation, but logically paired with controller performance) often differ between generations (R2 vs. R3) and performance tiers (70 vs. 90). The X70R2 NVRAM modules are typically not compatible with X90R3 controllers. Therefore, the engineer must swap the NVRAM modules along with the controllers to ensure the write cache is recognized.

Power Supplies: Both the X70R2 and X90R3 utilize the same high-capacity 1600W Power Supply Units . Unless the existing PSUs are faulty, they do not technically need to be swapped for the system to function, making "Controller and NVRAM" the precise minimum requirement for the logic upgrade.

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.

=========

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

=========

Understanding the strict physical drive population rules is a fundamental requirement for any Pure Storage Implementation Engineer. The front chassis of a standard 3U FlashArray (such as an //X50 or //X70) contains 20 dedicated capacity drive bays, numbered from 0 to 19.

When installing a new FlashArray that has been ordered with a single, baseline data pack—which always consists of exactly 10 DirectFlash Modules (DFMs) or DFMDs—the physical insertion order is not arbitrary. The official hardware installation guidelines dictate that these 10 drives must be populated sequentially starting in bay 0, from left to right .

By filling bays 0 through 9 continuously, the engineer ensures that the Purity operating system can logically group the physical media into a contiguous, balanced Wide Write Group (WWG) for optimal parity calculation and wear leveling. Leaving gaps between the drives, or starting the installation in the higher-numbered bays (such as bay 10 or bay 19), violates the tested physical airflow characteristics of the chassis and will trigger hardware topology alerts during the hardware_check.py validation phase of the array initialization. If a second data pack is ever purchased for capacity expansion, those subsequent 10 drives would then seamlessly populate bays 10 through 19, again from left to right, completing the primary chassis.

Hardware Non-Disruptive Upgrades (HWNDU) rely strictly on the array being in a fully healthy state before the process begins. The validate-array-health check is designed to gate the upgrade if any component that provides redundancy or data integrity is compromised. NVRAM (Non-Volatile Random Access Memory) modules are critical components in the FlashArray architecture; they store in-flight write data to ensure it is persistent before being destaged to flash.

A "Code 60" alert specifically points to a hardware issue with an NVRAM module. While the //X70 model indeed has redundancy (often using multiple NVRAM modules), proceeding with an upgrade while one is degraded puts the array at risk. During an NDU, controllers reboot and failover; running on reduced redundancy during these critical operations is not supported and is blocked by the health checks.

The correct first step for an Implementation Engineer is to attempt to reseat the unhealthy NVRAM module . Often, connection issues or transient seating faults can trigger these alerts. After reseating, the engineer must run the health check again to confirm the module status has returned to "healthy." If the module remains unhealthy after reseating, it must be replaced before the upgrade can proceed. You cannot simply disable it or ignore it, as the upgrade script will likely refuse to continue to protect data integrity.

=========

To specifically verify the shelf cable connections and validate the SAS topology during an installation, the correct command is storage_view.py config .

While standard Purity CLI commands like purehw list (Option B) can show the presence and general status of enclosures, they often do not provide the granular, low-level details of the SAS cabling map required to troubleshoot or verify physical redundancy paths (Side A vs. Side B connectivity).

storage_view.py is a specialized Python utility script included in the Purity operating system, primarily intended for use by Implementation Engineers and Support. Running storage_view.py config (or similar arguments like enclosures) outputs a visual or tabular representation of the backend cabling, explicitly showing how the controllers are chained to the expansion shelves. This allows the engineer to confirm that the cabling matches the strict "stacking" rules (e.g., verifying that the SAS loops are closed and redundant) and to identify issues like cross-cabling or disconnected paths that a simple "status=healthy" flag might miss during the initial build.

During a hardware upgrade, software update, or initial deployment, FlashArray controllers are frequently rebooted. When a controller comes back online, the underlying Linux kernel boots first, followed by the proprietary Purity//FA operating system services. It is an essential responsibility of the Implementation Engineer to verify that the controller has not just powered on, but has successfully loaded its storage processes and rejoined the high-availability cluster.

The definitive Purity CLI command used to validate this state is pureadm list .

Executing pureadm list outputs a clear, tabular view of the array's cluster topology. It displays the hostname of both controllers (CT0 and CT1) and explicitly lists their current operational state.

A healthy cluster will show one controller in the "Primary" state (actively handling backend drive negotiations and primary administrative duties) and the other in the "Ready" / "Secondary" state.

If a controller has rebooted but the Purity services have not fully started, or if it is struggling to synchronize its NVRAM mirror with the primary node, pureadm list will flag that controller's status as "Offline," "Updating," or "Not Responding."

Options like pureadm status or purecluster status are fabricated syntaxes. The standard, unmodified pureadm list command is the documented best practice for verifying that Purity services have cleanly initialized and High Availability (HA) is restored.

Executing a Hardware Non-Disruptive Upgrade (HWNDU) is a complex procedure involving the physical removal and replacement of core processing nodes while host I/O continues uninterrupted. Occasionally, after the new controllers are seated, cabled, and initialized, the cluster may fail to fully form a healthy quorum, manifesting as a "health not responding" state during a pureadm status check.

Before immediately escalating the issue to Pure Storage Support, the Implementation Engineer is expected to perform basic, front-line triage to understand exactly what is blocking the system's high-availability formation. The most effective diagnostic tool for this is the puremessage CLI suite.

While the standard puremessage list command displays standard administrative alerts, a controller in a degraded state often suppresses deeper hardware faults or internal cluster mismatch errors from the standard user view. By executing puremessage list --open --hidden , the engineer forces Purity to reveal all active, unresolved alerts, including internal, low-level system faults normally hidden from standard administrator accounts. This output might reveal issues such as a mismatched firmware version on a newly inserted PCIe card, an improperly seated NVRAM module, or a disconnected internal NTB (Non-Transparent Bridge) link. Armed with this specific error code or fault description, the engineer can either resolve the physical issue immediately or provide the exact fault string to Pure Support, drastically accelerating the time to resolution.

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.

To expand a FlashArray//X10 from a 5/5 (fully populated chassis with two 5TB equivalent packs) to an 11/11 (two 11TB equivalent packs) configuration, the correct action is to install a swing shelf with loan capacity .

The Constraint: The "5/5" notation implies the chassis slots are already occupied by the existing media. Since the customer is replacing the existing packs with larger ones (Capacity Consolidation) rather than just adding new ones, the engineer needs a place to put the data during the swap.

Why Swing Shelf: The FlashArray//X10 chassis has limited slots. You cannot simply pull a pack (Option A) if the remaining pack doesn't have enough free space to hold all the data (which is typical in upgrade scenarios). A Swing Shelf (temporary external SAS or NVMe shelf provided by Pure) is attached to the array. The data is evacuated from the internal drives to this shelf. Once the internal slots are empty, the new 11TB packs are installed. The data is then moved back from the shelf to the new packs, and the shelf is removed.

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 initiate a Purity Operating Environment (OE) software upgrade from the Command Line Interface (CLI), the correct command is pureinstall .

pureinstall : This command manages the upgrade workflow. It typically takes an image file (ISO) as an argument or downloads it from the repository, unpacks it, performs pre-flight checks, and then applies the update to the controllers in a non-disruptive rolling fashion.

purereboot is used to restart a controller or the array but does not install software.

puresetup is used for the initial configuration of network settings and array names, not for software updates.

=========

FlashArray performance and capacity efficiency are optimized when drives are grouped into "Wide Write Groups" (typically 20 modules). Purity OS generally enforces strict homogeneity within a write group to ensure consistent performance and reliability. Specifically, mixing standard DirectFlash Modules (DFM) with DirectFlash Modules with Distributed NVRAM (DFMD) in the same write group is restricted by default because of the architectural differences in how they handle persistent memory and I/O acknowledgment.

However, in upgrade scenarios where a customer is expanding an existing 16-module DFM group to a 20-module group using newer DFMD spares or expansion packs, Purity includes an engineering tunable to permit this mixed configuration. The correct procedure is to physically install the new DFMDs and run the admission command. Because of the mix, the array might initially hesitate or create a separate group. To force the creation of a single 20-drive Wide Write Group (WWG) , the Implementation Engineer must work with Pure Storage Support to apply the specific tunable puretune --set ALLOW_DFMD_IN_DFM_WWG 1 . This overrides the default restriction, allowing the system to merge the disparate module types into a single, high-efficiency capacity pool.

=========

The Customer is the mandatory party required to provide completion sign-off before the Implementation Engineer leaves the site.

According to the FlashArray Implementation Service Brief and standard operating procedures, the final step of the deployment phase is the "Project Sign-off." After the engineer has racked, cabled, initialized, and verified the array's health (often demonstrating connectivity and the Purity GUI), the customer must formally acknowledge that the installation meets the agreed-upon scope of work. This sign-off serves as the legal and operational acceptance of the hardware and software implementation.

While the Account Team manages the commercial relationship and Support may assist with technical hurdles, neither can validate that the physical implementation meets the customer's specific on-site requirements or that the "handover" of administration has occurred. The customer's signature (physical or digital) on the implementation checklist or service completion form signals the transition from the "Deployment" phase to the "Production/Support" phase.

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.

=========

To verify the history and transmission status of Phonehome log bundles, the correct command is purearray phonehome --list .

Before starting a controller upgrade (NDU), it is mandatory to ensure that the array can successfully transmit diagnostic data to Pure Storage. This allows Support to review the "pre-flight" checks and ensures that if an issue occurs during the upgrade, logs will be available for triage.

Usage: Running purearray phonehome --list displays a table of recent log bundles generated by the system.

Verification: The Engineer must look at the Status column for the most recent entries. A status of "uploaded" confirms that the array has successfully connected to the Pure Storage cloud and transferred the data. If the status is "queued" or "failed," the upgrade should not proceed until network connectivity (firewall/proxy) is resolved. Options A and C are incorrect CLI syntax for this specific verification task.

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 executing a capacity migration or consolidation on a highly utilized Pure Storage FlashArray (such as an //X90 Gen 2 at 90% capacity), physical and logical space limitations dictate the required procedure. The FlashArray chassis only contains 24 front-facing capacity drive bays. In this scenario, the chassis is fully populated with 10 drives in slots 0-9 and 14 drives in slots 10-23.

Because all physical chassis slots are occupied, there is nowhere to physically insert the new 91TB (10 x 9.1TB) DirectFlash Modules. Furthermore, because the array is at 90% capacity, there is insufficient logical free space remaining to evacuate the 22TB data pack into the existing 63TB pack's free capacity. Standard evacuation requires the system to non-disruptively move data off the target drives before they can be safely removed, which is mathematically impossible here without external capacity.

To resolve this, the officially supported method is to install a temporary "swing shelf" (Option B). A swing shelf acts as a temporary expansion vessel. The Implementation Engineer physically racks the swing shelf, connects it to the array, and inserts the new 91TB data pack into it. Purity can then safely evacuate the data from the old 22TB chassis data pack onto the new drives in the swing shelf. Once the evacuation completes, the old drives are decommissioned and removed, the new 91TB drives are seamlessly relocated into the chassis slots 0-9, and the swing shelf is removed and returned.

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.

To perform parallel evacuation of multiple SAS shelves , the FlashArray must be running Purity//FA 6.0 or higher.

Prior to Purity version 6.x, the shelf evacuation process (used during capacity consolidation or shelf retirement) was a serialized operation. An Implementation Engineer had to issue the evacuation command for one shelf, wait for all data to move to other storage within the array, and physically remove that shelf before starting the process for the next one. This could be time-consuming for large clusters of legacy SAS shelves.

With the release of Purity//FA 6.0, Pure Storage introduced significant enhancements to data mobility and background operational efficiency, including the ability to issue evacuation commands for multiple external shelves simultaneously. The system's intelligent scheduler manages the I/O bandwidth to ensure that the parallel data movement does not impact frontend host performance. While having sufficient free space (Option C) is logically necessary to hold the evacuated data, the specific functional capability to trigger concurrent evacuations is a software feature tied strictly to the Purity 6.x code base. Option B is irrelevant to the software capability of the array.

In a Non-Disruptive Upgrade (NDU), ensuring that the host is correctly multipathed and balancing I/O across all paths is critical before taking a controller down. If a host is only using paths to the controller about to be rebooted (CT0, for example), taking that controller offline would cause an outage.

The command iobalance --sampletime 30 (or its wrapper purehost monitor --balance) is the standard tool used during the upgrade procedure to validate this state.

iobalance : This script samples the I/O throughput on all ports for a specified duration (e.g., 30 seconds).

It analyzes the distribution of I/O. If it detects that I/O is heavily skewed or missing entirely on the "secondary" paths (the ones that will survive the reboot), it flags a warning.

This allows the Implementation Engineer to pause and remediate the host multipathing configuration (e.g., fixing a bad cable or zoning issue) before proceeding with the controller removal, ensuring the NDU remains truly non-disruptive.

The FlashArray//XR4 maintains the standard port assignment convention established in previous generations for its onboard Ethernet interfaces.

ETH2 and ETH3 are the default ports designated for Replication traffic.

ETH0 and ETH1 are reserved for Management.

ETH2 and ETH3 are configured by Purity defaults to handle the heavy bandwidth of asynchronous or synchronous replication.

While these assignments can be modified in software, the physical ports labeled eth2 and eth3 on the rear of the chassis are the intended primary interfaces for this function. Implementation Engineers should cable these ports to the replication network switches during the initial install.

=========

Executing an intra-series Hardware Non-Disruptive Upgrade (HWNDU) from a FlashArray//XR3 to an //XR4 is a highly orchestrated procedure. It involves failing over active I/O responsibilities, physically removing legacy controller nodes, and seamlessly introducing newer generation hardware without causing any downtime for the connected hosts.

Before an Implementation Engineer physically unplugs or removes a secondary controller—or initiates a failover to take the primary controller offline—it is an absolute prerequisite to verify that the frontend host multi-pathing is healthy. If a host is accidentally single-pathed to the controller that is about to be removed, an all-paths-down (APD) event will occur, causing immediate application disruption.

To safely validate this from the array's perspective, the engineer must execute the iobalance --sampletime 30 command within the Purity CLI. This specialized diagnostic command forces the array to actively sample and monitor the incoming SCSI/NVMe read and write commands across all frontend target ports for a continuous 30-second window. The output produces a detailed matrix showing exactly how traffic is distributed across both controllers and all active host initiators. If the data confirms that I/O is cleanly balanced and redundantly flowing across the surviving controller's paths, the engineer can confidently proceed with the physical removal phase of the HWNDU.

In the Purity//FA Graphical User Interface (GUI), the management of FA File resources is integrated into the core "Storage" navigation pane. To manage specific file system directories—such as creating new exports, setting quotas, or managing directory-level policies—the Implementation Engineer must navigate to Storage > File Systems .

Within this view, the engineer can see the list of provisioned file systems. By clicking into a specific file system, they can access the "Directories" sub-tab or detailed view where folders (directories) within that file system can be explicitly managed.

It is important not to confuse this with "Directory Services," which is located under the Settings menu. "Directory Services" (Option B) refers to the configuration of Active Directory (AD) or LDAP connections for user authentication and identity mapping, not the management of the actual file storage structure. Similarly, the Analytics tab (Option C) provides performance metrics but does not offer configuration capabilities for creating or modifying directories.

=========

For a Pure Storage FlashArray to fully utilize its predictive support capabilities, it must maintain a persistent, secure outbound connection to the Pure1 cloud infrastructure. This allows the array's Callhome Connection Manager (CCM) to transmit telemetry data, hardware alerts, and heartbeat signals. However, in many enterprise environments, storage management networks do not have direct, unfiltered access to the public internet. Instead, all outbound HTTP/HTTPS traffic must be routed through a corporate proxy server.

To facilitate this, the Implementation Engineer must configure the FlashArray to tunnel its Call Home traffic through the customer's proxy. The officially supported Purity CLI command to achieve this is purearray setattr --proxy https:// < proxy_address > : < port > .

By executing this command, the system modifies its global network attributes. Purity immediately updates the internal routing daemon, instructing it to encapsulate all outgoing Pure1 management traffic and direct it to the specified proxy IP or hostname on the designated port (e.g., port 8080 or 3128). Options B, C, and D are fabricated commands that do not exist within the Purity CLI framework. Once the proxy is set, the engineer should always validate the configuration by running purearray test phonehome to ensure the proxy is properly allowing the traffic to pass through to the Pure Storage cloud endpoints.

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.

=========

Upgrading from a FlashArray//X to a FlashArray//XL involves a significant architectural change, often requiring a data migration or a specific "chassis replacement" workflow known as a Data-in-Place upgrade where the new chassis temporarily acts as an expansion shelf. In this specific procedure, the new FlashArray//XL chassis is not immediately populated with its final drives (DFMDs) before power-on because it first needs to be configured to accept data or join the cluster in a controlled state.

The procedure requires the Implementation Engineer to boot the FlashArray//XL chassis first and configure it into Shelf Mode (SPM) . Only after the chassis is successfully running in this mode—effectively acting as a passive SAS/Ethernet attached shelf to the existing controllers—are the DirectFlash Modules (DFMd) inserted.

Inserting them earlier could cause the array to attempt a full boot sequence or initialize a new array instance, complicating the upgrade logic. By waiting until Shelf Mode is confirmed, the engineer ensures that the modules are recognized correctly as part of the migration target resources, allowing Purity to manage the layout and data redistribution correctly from the source array.

=========

When new capacity (a data pack) is physically installed into a FlashArray, the drives are detected by the system but are not automatically added to the storage pool to prevent accidental data overwrites or configuration errors. They appear in an "unadmitted" state.

To logically add these drives to the array's capacity, the Implementation Engineer must explicitly admit them. The command to perform this action is purearray drive admit (or puredrive admit in some contexts, but purearray drive admit is the specific option provided and valid). This command triggers the Purity software to format the new drives, add them to the system's write groups, and begin rebalancing data across the expanded capacity. Without running this admission command, the drives will remain visible but unusable for storage.

=========

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.