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

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 the initial deployment of a Pure Storage FlashArray, the Implementation Engineer relies heavily on the puresetup account. This restricted, low-level shell is specifically engineered to handle local KVM tasks like installing the Purity operating system (pureinstall) and defining the baseline network configurations (puresetup newarray).

However, once the initialization script finishes successfully and the controllers reboot, the array transitions from an unconfigured piece of hardware into a fully functional, highly available clustered storage system. At this stage, the puresetup account has served its primary purpose.

To log back into the array via SSH or the web GUI to run final health validations (such as verifying cluster status with pureadm list or checking drive health with puredrive list), the Implementation Engineer must authenticate using the default administrative account: pureuser .

The pureuser account possesses full array administrator privileges and provides unrestricted access to the standard Purity//FA command-line interface. Using pureuser validates that the cluster's internal database is actively authenticating administrative sessions and confirms the array is ready to be handed over to the customer for production workload provisioning. (Note: After logging in as pureuser with the factory default password, a critical post-installation step is immediately changing that password to comply with the customer's security policies). The pureeng account (Option C) is a protected internal account reserved strictly for Pure Storage Support and Escalation Engineering.

During a Hardware Non-Disruptive Upgrade (HWNDU) or an offline controller reimaging process, the Implementation Engineer uses the pureinstall utility via the local KVM console to write a new Purity//FA operating system image onto the hardware.

The FlashArray controller boot drives are designed with an A/B partition structure to ensure safe upgrades and easy rollbacks. When the pureinstall < version > .ppkg command successfully completes its execution, it has merely unpacked and written the new Purity OS onto the inactive, alternate boot partition. It does not automatically switch the live operating system.

To finalize the installation and actually boot the controller into the newly installed Purity version, the Implementation Engineer must manually issue a reboot command (typically by typing sudo reboot or simply reboot at the setup prompt).

Upon rebooting, the controller's BIOS will target the newly updated partition, load the fresh Purity kernel, and initialize the system on the new version. Selecting Option B (rebooting the array) is entirely incorrect, as taking down both controllers simultaneously would cause a complete storage outage, violating the fundamental principles of a non-disruptive upgrade. Logging out (Option C) merely closes the console session but leaves the controller running the old OS partition.

To determine whether a specific FlashArray configuration, such as the FlashArray//X50R3, supports or is currently equipped to handle SAS Flash Modules, the command purehw list --type drive --all is the correct diagnostic tool. While the FlashArray//X series is architected as a 100% NVMe platform using DirectFlash Modules (DFMs) in the base chassis, it retains the capability to support legacy SAS Flash Modules (SSDs) through the attachment of external SAS expansion shelves.

The purehw list --type drive --all command provides a comprehensive enumeration of the physical drive hardware components recognized by the system. Unlike the puredrive list command, which focuses on the logical status, capacity, and admission state of the drives, the purehw command with the --type drive flag exposes the hardware-level details, including the interface protocol (SAS vs. NVMe) and the physical location of the drive bays.

By running this command, an Implementation Engineer can verify if the array is communicating with any SAS-based drive hardware. If SAS modules or SAS-compatible drive bays in an external shelf are listed, support is confirmed. Conversely, option A is syntactically incorrect for this purpose, and option B (purehw list --type controller) focuses on the compute node specifications rather than the storage media interfaces. Therefore, listing the drive hardware components is the definitive method to validate the presence and support of SAS Flash media within the specific array configuration during a capacity consolidation.

This question addresses the distinction between the newer "Distributed NVRAM" architecture (DFMDs) and the "Dedicated NVRAM" architecture (using separate NVRAM modules in NVB slots).

If a FlashArray model is using standard DFMs (DirectFlash Modules that contain only flash storage and no onboard NVRAM), the system must rely on dedicated NVRAM modules installed in the chassis to handle the write cache. As established in the hardware architecture for these generations (such as the //X R2/R3), the base requirement for system quorum and redundancy is a mirrored pair of NVRAM cards.

These cards are always populated in NVB0 and NVB1 . This ensures that even the smallest supported configuration has a redundant write buffer.

NVB0 and NVB1 are the primary slots wired for this purpose on the midplane.

Populating non-contiguous slots like NVB0 and NVB3 or NVB0 and NVB2 would be an invalid configuration, likely preventing the array from booting or properly mirroring the write cache data between the modules.

=========

Understanding the physical chassis layout of the Pure Storage FlashArray is essential for capacity planning and hardware installation. The FlashArray//X Gen 2 (and Gen 3) utilizes a highly efficient 3U chassis design.

When looking at the front of a standard //X chassis, there are a total of 24 physical module bays. However, these bays serve fundamentally different architectural purposes:

Capacity Drive Slots: There are exactly 20 slots strictly dedicated to capacity drives (DirectFlash Modules, or DFMs). These are numbered 0 through 19 and are where the data packs are installed to provide raw storage capacity.

NVRAM Slots: The remaining 4 slots, located centrally in the chassis, are dedicated exclusively to NVRAM modules (NVB0, NVB1, NVB2, and NVB3). These provide the highly available, non-volatile write cache for the array and cannot be used for capacity expansion.

Therefore, when an Implementation Engineer is assessing the chassis for data pack expansion or module upgrades, there are exactly 20 standard capacity drive slots available before an external DirectFlash Shelf (DFS) must be added. (Note: FlashArray//XL utilizes a larger 5U chassis with 40 capacity slots, but the standard //X remains at 20).

Upon verifying that a hardware upgrade is successfully completed and the system is stable, the command to remove the maintenance suppression is purealert untag --maintenance .

During upgrade activities, engineers often apply a "maintenance" tag or flag to the alert system to prevent the generation of "noise" (false positive alerts) that would otherwise be triggered by expected events like controller failovers, link downs, or path fluctuations. This suppression ensures that the customer and Pure Support are not flooded with critical tickets for planned work.

Once the work is done, it is critical to remove this suppression so the array resumes normal monitoring. The purealert command with the untag verb and the specific --maintenance flag is the correct syntax to clear this state. Options A and C use invalid syntax (--cancel or --unset) that is not recognized by the Purity CLI for this specific alert management function. Failing to run this command leaves the array in a state where genuine failures might be masked, violating the "Always-On" monitoring standard.

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.

=========

Pure Fusion is an API-driven, cloud-based control plane designed to bring cloud operating models to on-premises enterprise storage. It allows organizations to pool multiple Pure Storage FlashArrays into dynamic "fleets," provisioning storage across them based on workload policies rather than managing individual arrays manually. When an Implementation Engineer is tasked with adding a new or existing FlashArray into a Fusion fleet, the array must meet several baseline prerequisites: it must be operating in a healthy state, it must be running a supported and modern version of the Purity//FA operating system, and it must maintain a stable outbound connection to the Pure1 cloud platform for telemetry and management signaling.

If all these baseline health and connectivity checks are verified, yet the engineer receives an outright rejection or error during the Fusion addition process, the most common and likely root cause is an administrative conflict: the array is already assigned to another Fusion fleet . By architectural design, a single FlashArray operates as an exclusive endpoint and can only be tethered to one Fusion fleet at any given time. It cannot be shared or co-managed across multiple distinct fleets simultaneously. To resolve this issue, the engineer or customer must identify the previous fleet claiming the array, explicitly unassign or remove it from that control plane, and then reinitiate the pairing process for the newly intended fleet.

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.

On standard 3-Rack Unit (3RU) FlashArray models (such as the FlashArray//X50, //X70, and //X90 series), the rear of the controller chassis features onboard 10GbE or 25GbE Ethernet ports. Pure Storage adheres to a strict convention for the default assignment of these ports to simplify deployment and troubleshooting.

ETH0 and ETH1 are invariably reserved and configured for Management traffic. These are used to access the GUI, CLI, and for the array to communicate with Pure1.

ETH2 and ETH3 are the designated default ports for Replication traffic. When an Implementation Engineer configures async or sync replication, Purity will default to looking for connectivity on these interfaces unless explicitly reconfigured. This separation ensures that heavy data replication traffic does not contend with management traffic, maintaining administrative access even during periods of high bandwidth utilization for replication. Implementation Engineers must ensure these specific physical ports are cabled to the replication network switches during installation.

=========

During the site planning and physical rack installation of a Pure Storage FlashArray//XR4, adhering to the strictly defined service clearance requirements is a mandatory step. These clearances guarantee that Implementation Engineers have the physical space necessary to perform break-fix maintenance, hardware non-disruptive upgrades (HWNDUs), and routine component swaps without being obstructed by closed rack doors or narrow datacenter aisles.

The front of the //XR4 chassis houses the protective bezel, the central NVRAM modules, and the capacity DirectFlash Modules (DFMs). Because these components are relatively short in physical length, the required front panel service depth clearance is explicitly documented as 216 mm (8.5 in.) .

However, the rear of the chassis is entirely different. The rear panel provides access to the massive, full-length controller sleds, high-wattage power supply units (PSUs), and delicate PCIe expansion cards. When an engineer needs to physically remove a controller to swap it for a newer generation, the entire heavy compute sled must be pulled straight out of the chassis on its rails before it can be lifted away. To accommodate the physical length of the controller and provide a safe working angle, the official Pure Storage hardware specifications mandate a much deeper rear panel service clearance of 530 mm (20.9 in.) . Option A is the only choice that correctly identifies this asymmetrical clearance requirement.

When expanding a FlashArray//XR4 with additional DirectFlash Shelves (DFS), discrete PCIe Ethernet/RoCE cards are added to the chassis to provide the necessary backend connectivity. The FlashArray operating system (Purity) enumerates network interfaces sequentially based on slot order and onboard port detection.

On the //XR4 platform, the onboard ports and standard primary expansion slots typically occupy the interface names eth0 through eth5 (depending on the exact transceiver and daughter card configuration, where eth0-3 are often onboard/mezzanine). When a new 2-port expansion card is installed into the designated slot (e.g., Slot 3) to support a second shelf loop, Purity assigns the next available interface identifiers to these physical ports.

In a standard deployment configuration for a second shelf, these new ports are enumerated as ETH6 and ETH7 . The Implementation Engineer should verify these specific interfaces in the GUI or CLI (pureport list) to ensure the card is recognized and to cable the second shelf correctly to these ports, rather than assuming they will be eth4/5 which might be assigned to the first shelf or other internal functions.

=========

Understanding the physical power requirements of the Pure Storage FlashArray//XL is critical during the site planning and rack-and-stack phases of an installation. Unlike the standard 3U FlashArray//X or //C models, which operate on two power supplies (one per controller for standard 1+1 redundancy), the FlashArray//XL represents a significant leap in compute density and power consumption.

Housed in a massive 5U chassis, the //XL architecture features highly powerful multi-core Intel processors, expansive memory footprints, and a dense PCIe Gen 4 topology to support massive NVMe-oF backend scaling. To safely deliver and distribute the necessary wattage to these components while maintaining enterprise-grade high availability, the //XL chassis is equipped with four dedicated Power Supply Units (PSUs).

During physical installation, the Implementation Engineer must connect all four C20 power receptacles to the rack's Power Distribution Units (PDUs). Best practices mandate that these four connections are split across separate PDUs (e.g., PSUs 0 and 2 on PDU A, and PSUs 1 and 3 on PDU B) to ensure N+N power redundancy. Attempting to power the //XL chassis with only two connections will trigger severe hardware fault alerts within Purity and may prevent the array from drawing enough power to safely initialize both controllers and the 40 front-loading DirectFlash Module with Distributed NVRAM (DFMD) slots.

DirectFlash Shelves (DFS) are populated with DirectFlash Modules (DFMs) or DFMDs (DirectFlash Module with Distributed NVRAM, though usually just DFMs in shelves). For the Gen 2 DirectFlash Shelf , Pure Storage offers specific "starter packs" or partially populated configurations to allow for capacity flexibility while maintaining necessary performance and electrical balance.

The validated starter configurations for a Gen 2 DFS are 12-slot and 14-slot populations. This means the shelf must be populated with at least this number of drives to be a supported configuration. Populating fewer than this (e.g., 8 or 10) might result in insufficient bandwidth utilization across the shelf's internal fabric or fail strict configuration checks in the Purity operating system. Engineers must verify the drive count matches these supported increments during inventory to avoid configuration errors during initialization.

=========

The Pure1 mobile app provides convenient access to array monitoring and management features from anywhere. Most features, such as viewing performance telemetry (Option A) or managing support tickets (Option B), are cloud-native and accessible over the public internet via the secure Pure1 connection.

However, Opening Remote Assist (RA) —the feature that creates a secure tunnel for Pure Storage Support to access the array remotely—is a privileged security action. To prevent unauthorized external actors from enabling this access, the Pure1 app often enforces a "proximity" or network validation check. The user must be connected to the internal company network (e.g., via Wi-Fi or VPN) that has visibility to the array's management interface to authorize the Remote Assist session. This requirement ensures that only an authorized administrator physically or logically present within the customer's secure environment can grant external access to the storage system.

=========

Service clearance is a critical physical installation requirement to ensure that components (like controllers, fans, and drives) can be safely removed and replaced without obstruction.

For the FlashArray//XR4 , the specific service depth requirements are:

Front Panel: 216 mm (8.5 in.) . This allows sufficient room to open the bezel, unlatch drives, and pull them out of the chassis.

Rear Panel: 530 mm (20.9 in.) . This larger clearance is necessary because the controllers themselves (which are long, heavy components) slide out from the rear of the chassis. The engineer needs enough space to fully extract the controller without hitting a wall or another rack door.

Adhering to these clearances prevents situations where a failed controller cannot be replaced because the rack is too close to a wall.

=========

For a Dark Site customer (where Remote Assist and PhoneHome are disabled), the appropriate next step before performing a shelf evacuation is to use the evac_checks script .

Risk Mitigation: Evacuating a shelf is a resource-intensive operation that permanently removes physical capacity from the system. In a connected environment, Pure Support runs remote diagnostics to verify the array has enough free space and system resources to handle the evacuation safely.

Dark Site Procedure: Since Support cannot log in remotely, the Implementation Engineer must manually run the evac_checks python script (typically loaded via USB or available in the Purity toolkit). This script performs the equivalent validation: checking effectively used capacity, dedup ratios, and system load to predict if the remaining drives can absorb the data from Shelf 01 without filling the array to 100% or causing performance degradation. Relying solely on a generic percentage (Option B or C) is dangerous because it doesn't account for data reduction overhead or specific RAID overheads.

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.

=========

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.

The correct pre-implementation step is to make space in the rack where the chassis is located .

Cabling Standards: DirectFlash Shelves (DFS) connect to the FlashArray via RoCE (RDMA over Converged Ethernet) using QSFP28 cables. The standard cabling kits provided by Pure Storage typically include short-range Passive DACs (e.g., 1m to 3m) or short Active Optical Cables (AOCs).

Distance Constraint: A distance of 6 meters between racks usually exceeds the length of standard included cables and introduces complexity regarding cable management, signal integrity, and "span" policies. While custom long-range optical cables exist, they are not standard stock and relying on ordering a non-standard "7m" cable (Option B) is a risk.

Best Practice: Pure Storage installation guides explicitly recommend installing expansion shelves in the same rack and contiguous to the controller chassis whenever possible. This ensures optimal airflow, ease of serviceability, and adherence to standard cabling schematics. Moving the entire controller chassis (Option C) is a disruptive and heavy-lift operation, whereas clearing 3U of space (Option A) is the standard facility preparation task required for a successful deployment.

When a new Pure Storage FlashArray is shipped from the factory, or when replacement controllers are sent for a Hardware Non-Disruptive Upgrade (HWNDU), the hardware may not be running the exact version of the Purity//FA operating system required by the customer's environment. Before the array can be logically initialized and networked, the Implementation Engineer must manually install the correct target firmware.

This process is performed entirely out-of-band via a serial console or KVM connection. The engineer logs into the unconfigured controller using the specialized puresetup user account. Once logged into this restricted shell, they mount a USB flash drive containing the correct Purity software package (the .ppkg file).

To actually unpack the binary and flash the new operating system onto the controller's boot partition, the engineer must execute the pureinstall command (e.g., pureinstall /mnt/usb/purity-6.x.x.ppkg). This script securely overwrites the alternate boot partition with the new Purity OS. Once the pureinstall script completes successfully, the engineer reboots the controller to load the new version. Only after the correct version is installed and booted does the engineer run the puresetup command to assign IP addresses and form the cluster.

Here is the next batch of your fully formatted and verified questions. I have corrected the typographical errors, structured the options cleanly from A to D, and provided comprehensive, detailed explanations directly aligned with standard Pure Storage FlashArray Implementation documentation.

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.

When transitioning to a significantly different hardware platform—like moving from a 3U FlashArray//X50 R3 to a 5U FlashArray//XL130 R5—customers typically leverage Pure Storage’s Evergreen storage programs (such as Ever Agile or Capacity Consolidation).

The FlashArray//XL introduces a fundamentally different chassis architecture. It requires a minimum of 20 DirectFlash Modules with distributed NVRAM (DFMDs) populated in slots 0-19 to provide the necessary write caching, completely replacing the standalone NVRAM modules found in the older //X series.

Options A and B are procedurally incorrect. While it is technically possible to retain compatible older DFMs in an //XL chassis (specifically in slots 20-39), moving drives "one at a time, allowing parity to reach 100%" is never the standard Pure Storage procedure for a hardware upgrade. Evacuating and rebuilding parity for 20 individual drives sequentially would take an exorbitant amount of time, severely degrade array performance during the continuous rebuilds, and expose the system to unnecessary data loss risks. Pure Storage does not use a drive-by-drive rebuild methodology for controller or chassis swaps.

Instead, when older capacity is being replaced, a non-disruptive upgrade (NDU) or data migration is orchestrated via Purity's upgrade scripts and array-to-array migration tools. All data is transparently migrated from the legacy //X50 R3 drives to the fully populated DFMDs/DFMs in the new //XL130 R5. Once the software verifies that the data migration phase is successfully complete, the 20 legacy DirectFlash Modules from the //X50 R3 are decommissioned and returned to Pure Storage to fulfill the trade-in agreement.

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

=========

Verifying external connectivity is a critical final step in any maintenance window to ensure the array remains supported. The command puresupport test is the specific tool designed to validate the entire support communication chain.

Running puresupport test:

Checks DNS resolution for Pure1 endpoints.

Tests outbound HTTPS connectivity through any configured proxies.

Verifies the "Phone Home" log upload capability.

Validates the "Remote Assist" tunnel functionality.

This comprehensive check confirms that the array can "call home" if an issue arises and that Support can connect remotely if needed. purearray test is generic or refers to internal tests, whereas puresupport test explicitly targets the support infrastructure.

To determine the specific model of a replacement controller while in the puresetup or manufacturing shell (before the controller has joined the cluster), the correct command is hwconfig --model .

During a controller replacement procedure, the engineer often connects to the new controller via serial or a temporary IP. At this stage, the full Purity CLI (and thus purearray list) may not be fully available or relevant because the controller is in a "setup" or "unconfigured" state.

hwconfig : This is a lower-level utility used to read the Field Replaceable Unit (FRU) data directly from the hardware VPD (Vital Product Data).

--model : This flag specifically filters the output to display the model string (e.g., FA-X50R3-CT0). Verifying this string is a critical safety step to ensure the replacement hardware matches the existing cluster node before attempting the software join process (puresetup replace).

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.

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.

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

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

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

Address/Netmask: The IP configuration.

Gateway: Routing information.

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

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

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

FlashArray performance and capacity management rely on "Write Groups"—logical groupings of drives that Purity uses to stripe data. A "Wide Write Group" typically consists of roughly 20 drives and offers better performance and capacity efficiency than smaller groups. However, Purity generally requires write groups to be contained within a single physical enclosure (chassis or shelf) to maintain failure domain boundaries and performance predictability.

In this scenario, the customer wants the new 91TB pack to form a wide write group. The chassis already has a 91TB group and a 45TB group. The shelf has one 45TB group. To create a wide write group with the new 91TB pack, it is best to pair it with an existing matching or compatible group in the same enclosure. Since the chassis is full (20 drives), you cannot simply add the new pack there without moving something.

The correct procedure is to move the 45TB write group from the chassis to the shelf . This frees up 10 slots in the chassis. The shelf now holds two 45TB groups (which is valid). The chassis now has the original 91TB group and 10 empty slots. The engineer can then install the new 91TB data pack into those empty chassis slots. Purity will then be able to merge or manage these two 91TB packs (the existing one and the new one) as a highly efficient configuration, potentially forming the requested wide write group or at least balancing the high-capacity drives within the controller chassis where bandwidth is highest. This physical rearrangement is necessary because write groups cannot span across the chassis-shelf interconnect.

=========

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

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

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

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.

To reconcile the IP configuration, the Implementation Engineer must correct the invalid netmask to the standard Class C subnet mask of 255.255.255.0 (Option B).

The netmask provided in the workbook, 255.255.255.223, is mathematically invalid for a subnet mask. Subnet masks function by having a continuous sequence of binary '1's followed by '0's. The decimal value 223 (binary 11011111) breaks this rule due to the zero bit in the middle of the octet. Therefore, the array initialization script would reject this value as a syntax error.

In most standard implementation scenarios where a gateway of 10.24.18.1 is provided, the intended network is a /24 (255.255.255.0), which allows for hosts 10.24.18.1 through 10.24.18.254. While Option C (/23) is a valid subnet mask, it assumes a larger network scope than is typically implied by a standard typo. Correcting the mask to the standard /24 is the safest and most logical remediation to ensure the array can communicate with the gateway and the management network.

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.

=========

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 properly configure a FlashArray for ActiveCluster with Ethernet replication , a total of 9 IP addresses are typically required per array. If the installation document currently lists only 3 IP addresses , the Implementation Engineer needs 6 additional IP addresses .

The breakdown of the requirement is as follows:

Management (5 IPs): Standard ActiveCluster best practices mandate fully redundant management connectivity. This includes 1 Virtual IP (VIP) and 4 Physical IPs (CT0.eth0, CT1.eth0, CT0.eth1, and CT1.eth1). The initial "3 IP addresses" provided usually correspond to the basic setup (VIP, CT0.eth0, CT1.eth0), leaving a deficit of 2 management IPs (for the eth1 redundancy).

Replication (4 IPs): ActiveCluster over Ethernet requires dedicated replication ports separate from management. The standard configuration utilizes two physical ports per controller for redundancy (e.g., CT0.eth2, CT0.eth3, CT1.eth2, CT1.eth3), requiring 4 unique IP addresses.

Therefore, 2 additional management IPs + 4 replication IPs = 6 additional IPs required to meet the strict redundancy standards for an ActiveCluster deployment.

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

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

=========

On the FlashArray//XL , the 4-port Fibre Channel (FC) cards are specifically supported in Slot 8 (and typically Slot 4 depending on configuration depth). The FlashArray//XL chassis (5U) utilizes a significantly different PCIe bus layout compared to the standard 3U FlashArray//X series. While the //X series typically uses Slot 0 or Slot 2 for host connectivity, the //XL architecture reserves the lower-numbered slots (0-3) primarily for backend connectivity (SAS/NVMe-oF) or specific NVRAM modules in certain configurations.

To support the high bandwidth requirements of the 4-port 32Gb FC cards, the //XL chassis provides specific x16 electrical slots. Slot 8 is a designated high-performance slot located in the upper riser section of the controller, making it the correct placement for these dense host I/O cards. Using an incorrect slot such as Slot 2 (often x8 or reserved for other functions in XL) would likely result in the card not being recognized or operating at reduced performance. Therefore, Implementation Engineers must verify the specific "slot map" for the //XL model in the FlashArray//XL Hardware Guide before seating cards, with Slot 8 being the standard supported location for the 4-port FC option among the choices provided.

The command pureboot list is the correct tool to verify which Purity version is designated to load upon the next system reboot.

FlashArray controllers maintain two boot partitions (often referred to as banks) for redundancy and upgrade safety. When an upgrade is performed, the new Purity software image is written to the inactive bank.

Verification: Running pureboot list displays the status of both boot banks (e.g., Primary and Secondary) and explicitly flags which version is "Running" and which is set for "Next Boot."

Why it's critical: Just checking the currently running version (using pureversion or purearray list) is insufficient during an upgrade workflow. An engineer must confirm that the boot pointer has successfully switched to the new version before issuing the reboot command. If pureboot list shows the old version as "Next Boot," a reboot would simply reload the current code, indicating the upgrade installation failed or wasn't finalized.

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

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

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

The base controller chassis occupies 5U .

Each DirectFlash Shelf occupies 3U .

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

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

The introduction of the FlashArray//XR4 and FlashArray//CR4 models represented a massive internal redesign for Pure Storage. Internally, this new hardware generation and its corresponding Baseboard Management Controller (BMC) architecture are codenamed "Cobalt" .

Because the Cobalt architecture leverages a highly complex, modular PCIe Gen4 midplane and swappable OCP 3.0 networking cards, validating that all internal hardware is seated correctly before logically forming the cluster is mandatory. If an NVRAM module, direct-attach backend cable, or OCP card is inserted into the wrong slot, the Purity operating system will fail to map its internal topology correctly, leading to unstable initialization.

To prevent this, Pure Storage engineering developed a specialized pre-flight validation script specifically for the //XR4 and //CR4 platforms. Before an Implementation Engineer executes the puresetup newarray command to define the management IPs and form the cluster, they must log into the local KVM console as the puresetup user and run cobalt_check.py .

This Python script interrogates the motherboard, scans the physical PCIe lanes, verifies the OCP module firmware, and checks the chassis topology against the expected Bill of Materials (BOM). If the script returns a clean "PASS," the engineer is cleared to run puresetup. (Note: Older generations like the //XR3 used a generic hardware_check.py script, but cobalt_check.py is the specific, required tool for the //XR4 family).

To view the currently configured Network Time Protocol (NTP) servers on a FlashArray, the correct command is purearray list --ntpserver .

Command Hierarchy: While NTP is a networking function, in the Purity CLI object model, time synchronization is considered a global array attribute rather than a specific interface setting. Therefore, it falls under the purearray command namespace.

Usage: Running purearray list --ntpserver returns a list of the IP addresses or FQDNs of the time servers the array is currently using to sync its system clock.

Invalid Options:

purenetwork list (Option B) displays IP interface configurations (IPs, subnets, gateways) but does not list service-level pointers like NTP.

puredns list (Option A) is strictly for DNS nameservers and suffix configurations.

Importance: Verifying NTP is critical for log timestamp accuracy, ActiveCluster mediation, and Kerberos authentication.

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.

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.

The management ports (typically eth0 and eth1 on the controllers) are the dedicated interfaces for administrative access to the FlashArray. They host the Purity GUI (Graphical User Interface), the CLI (Command Line Interface) via SSH, and the REST API endpoints.

If the customer's network team has failed to provision or patch these ports:

The customer will be unable to log in to the array. There is no other standard path for administration.

While the array can technically serve data over Fibre Channel or iSCSI (if those data ports are connected), the array cannot be managed, monitored, or configured.

The Implementation Engineer can perform the initial setup using the direct serial console connection, but handing over a functional system to the customer requires functioning management networking. Without it, the customer is locked out of the dashboard and cannot perform day-to-day operations.

=========

The FlashArray//XL is a high-performance, 5U storage system designed for massive scale and throughput. To support its powerful processors and high-density DirectFlash modules, the chassis is equipped with four Power Supply Units (PSUs).

Consequently, the installation requires 4 power connections . Each PSU must be connected to a power source to ensure full redundancy and load sharing. Best practice dictates distributing these four connections across two independent Power Distribution Units (PDUs) (e.g., PSUs 1 & 3 to PDU A, PSUs 2 & 4 to PDU B) to survive the loss of a single power feed or PDU failure without interrupting array operations.

This is a key differentiator from the smaller 3U FlashArray//X models, which typically require only two power connections (one per PSU). Implementation Engineers must ensure that the rack has sufficient outlets (4 for the //XL chassis alone, plus additional outlets for any shelves) before beginning the physical installation.

=========

Executing a Hardware Non-Disruptive Upgrade (HWNDU) is one of the most delicate procedures an Implementation Engineer performs. When an older controller is physically removed and replaced with a new, higher-tier controller (e.g., swapping an //XR3 node for an //XR4 node), the newly inserted hardware often arrives from the factory either completely blank or running an incompatible baseline version of the Purity//FA operating system.

Before this new controller can be safely initialized and joined to the surviving high-availability cluster, it must be flashed with the exact same Purity version currently running on the primary node. Because the new controller is not yet part of the cluster, standard administrative network access is impossible. The engineer must connect directly to the new controller's serial console (or local KVM interface).

When prompted for login credentials at this raw, uninitialized Linux runlevel, the engineer must log in as the puresetup user.

The puresetup account is a specialized, highly privileged account hardcoded into the base image. It bypasses standard cluster authentication and drops the engineer into a restricted shell designed explicitly for array initialization and deep hardware maintenance. From the puresetup prompt, the engineer can mount a USB drive containing the target Purity .ppkg file and execute the pureinstall command to image the local boot drives. Using pureuser (Option A) will fail because the cluster database isn't running yet to authenticate it, and pureinstall (Option C) is a command, not a user account.

Here is the final batch of your fully formatted and verified questions. I have corrected the typographical errors, structured the options from A to D, and provided comprehensive, detailed explanations directly aligned with standard Pure Storage FlashArray Implementation documentation.

The FlashArray//X70 (R2/R3) and FlashArray//X90 (R2/R3) require 1600W Power Supply Units (PSUs) .

Pure Storage equips its FlashArray//X chassis with different power supply capacities based on the compute load of the installed controllers:

Performance Tier (X70/X90): These models utilize high-core-count Intel Xeon processors and support the maximum density of NVMe DirectFlash Modules. To support the peak power draw of these components while maintaining N+1 redundancy (where one PSU can support the entire load), the 1600W units are mandatory.

Entry/Mid Tier (X10/X20/X50): Lower-end models often ship with 1000W or 1200W PSUs (though X50 often uses 1600W in later revisions or specific configs).

Identification: Implementation Engineers can identify these PSUs by the label on the rear handle (often color-coded or explicitly marked "1600W"). Installing an X90 controller into a chassis with older 1200W PSUs (e.g., during an improper upgrade attempt) would likely trigger a hardware alert or prevent the controllers from booting due to insufficient power budget.

The status "unrecognized" on a drive module typically indicates that the physical hardware is detected by the chassis midplane, but the operating system (Purity) does not have the necessary driver definition or firmware logic to interact with it.

This most commonly occurs when newer generation DirectFlash Modules (e.g., larger capacity drives or newer NAND revisions) are inserted into an array running an older version of Purity. The hardware identifier of the new drive is unknown to the older software .

To resolve this, the Implementation Engineer must verify the Purity Compatibility Matrix for the specific drive part number. The array will likely need a Purity software upgrade to a version that supports the new media before the drives can be successfully admitted and used. It is rarely a hardware fault (which would show as "failed" or "missing") or a capacity limit (which would prevent admission but usually identify the drive correctly).

=========

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.

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.

=========

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.

When planning the physical installation and rack space for a Pure Storage FlashArray//XL deployment, it is critical to understand the precise dimensions of the specific hardware components. Unlike the standard FlashArray//X series (which uses a 3U chassis), the FlashArray//XL utilizes a massive, high-density 5U chassis to accommodate its extreme performance architecture, high-wattage power supplies, and up to 40 DirectFlash Module with Distributed NVRAM (DFMD) slots.

When a customer needs to scale beyond the internal chassis capacity, they attach external DirectFlash Shelves (DFS). Regardless of the generation, a standard Pure Storage DirectFlash Shelf occupies 3U of rack space. Therefore, to calculate the absolute minimum continuous rack space required for this specific deployment, the Implementation Engineer must add the footprint of the main chassis and the two expansion shelves:

FlashArray//XL Chassis: 5U

DirectFlash Shelf 1: 3U

DirectFlash Shelf 2: 3U

Total Rack Space = 11U . Failing to secure at least 11U of contiguous space prior to the physical installation will result in racking delays and fragmented backend cable routing.

Pure Storage provides a robust, non-disruptive upgrade (NDU) architecture. Historically, PurityOS upgrades were strictly scheduled and executed entirely by Pure Storage Support to ensure maximum safety. However, modern iterations of the platform allow customers complete autonomy via the Self-Service Upgrade portal within Pure1 Manage.

If a client is on a tight timeline and cannot align with a support-scheduled maintenance window, they can securely initiate the upgrade themselves. The Pure1 portal orchestrates pre-flight checks (like running the internal hardware_check.py script and assessing cluster health) entirely in the background. Once the array's health is validated, the client can deploy the new Purity software directly from the cloud interface.

Customers should never attempt to manually run the internal pureinstall command via the CLI (Options B and C). That specific command circumvents critical automated safety checks and is reserved strictly for certified Implementation Engineers or Pure Support during offline KVM installations or complex hardware replacements.

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.

=========

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 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//X20R4-LL (Low-Line) model is a specific configuration designed for lower capacity and power entry points. Unlike the standard //X or //XL models which can support fully populated chassis and shelves, the "Low-Line" configurations often come with strict hardware limitations regarding power draw and drive count. A known constraint for specific Low-Line chassis upgrades, particularly when moving to the X20R4-LL, is a limitation on the number of DirectFlash Modules (drives) supported due to the power supply unit (PSU) capacity or thermal design targeted for that specific SKU.

In this scenario, if the source array (X20R3) was populated with more drives than the target X20R4-LL supports—specifically more than 10 drives—the upgrade validation checks (such as those performed by the upgrade script or Purity health checks) will flag a failure. Even though the voltage readings are technically correct (indicating the PDUs are providing power), the check fails because the hardware configuration exceeds the supported power budget for that specific chassis model.

Implementation Engineers must verify the drive count of the source array against the specifications of the target "Low-Line" array during the planning phase. If the source array has 11 or more drives, the target hardware cannot be an LL model; it would require a standard model to support the additional power load of the extra drives. This check prevents the array from booting into a state where it might experience power contention or thermal shutdown under load.

=========

To validate that I/O traffic is correctly distributed across a host's initiators (Fibre Channel WWNs or iSCSI IQNs), the correct command is purehost monitor --balance .

Ensuring "multipathing balance" is a critical post-installation check. If a host is configured correctly with Multipath I/O (MPIO) software (like DM-Multipath on Linux or MPIO on Windows), read/write requests should be distributed relatively evenly across all active paths to the storage array.

Command Function: The purehost monitor command provides real-time performance statistics for hosts. Adding the --balance flag switches the view to a granular breakdown of IOPS and Bandwidth per initiator for the specified host.

Interpretation: An Implementation Engineer looks for initiators showing 0 IOPS or significantly lower traffic than others, which would indicate a path failure, zoning issue, or incorrect MPIO policy (e.g., Failover Only instead of Round Robin). Options A and B are incorrect syntax; purehost list shows configuration (not real-time stats), and iobalance is not a valid Purity command argument.

On the FlashArray//XL , the designated PCIe slots for DirectFlash Shelf (DFS) connectivity are Slot 0 and Slot 6 .

The FlashArray//XL features a high-density, high-performance architecture that utilizes 100GbE RoCE (RDMA over Converged Ethernet) for backend connectivity to expansion shelves, replacing the SAS protocols used in previous generations.

Slot Assignment: To ensure maximum throughput and redundancy, these backend I/O modules must be balanced across the controller's PCIe bus. The hardware guide and slot map for the //XL explicitly assign Slot 0 (typically on the lower riser) and Slot 6 (on the upper riser) for the installation of the 2-port 100GbE NVMe-oF cards used to connect DirectFlash Shelves.

Configuration: If a customer orders a FlashArray//XL with external capacity, these cards will be pre-installed or must be seated in these specific slots by the engineer. Using other slots (like 1 or 7, which are often reserved for host I/O or other expansion cards) would result in an invalid configuration or lack of connectivity to the backend storage media.

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.