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

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

=========

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.

When dealing with power architecture on high-end arrays like the FlashArray//X90 R4, understanding the difference between the base chassis and the expansion shelves is critical. The base //X90 chassis—housing the powerful Intel CPUs, massive memory footprint, and primary PCIe lanes—draws significant wattage and strictly requires 200V-240V (208V minimum) power inputs to function. It will literally not power on if plugged into a 120V circuit.

However, a DirectFlash Shelf (DFS) is merely an external NVMe-oF expansion enclosure. It houses the DirectFlash Modules (DFMs) and the necessary backend I/O modules, but completely lacks the compute-heavy controllers of the main array. Because its overall power draw is significantly lower, the official Pure Storage hardware specifications state that DirectFlash Shelves are fully rated and completely supported to run on standard 120 VAC power indefinitely.

Therefore, the Implementation Engineer can confidently cable the DFS power supplies into the available 120V PDU connections without sacrificing any performance, redundancy, or hardware lifespan. It is a fully supported, permanent configuration.

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.

=========

When cabling and configuring the network topology for a Pure Storage FlashArray (including the //XR4 platform equipped with standard OCP mezzanine networking cards), the physical Ethernet ports are strictly mapped to default services by the Purity//FA operating system. Understanding these defaults prevents network collisions and ensures traffic is isolated appropriately.

The first two onboard ports, explicitly labeled eth0 and eth1, are always reserved for out-of-band Management traffic. These 1GbE ports handle GUI access, SSH, API calls, and outbound Pure1 telemetry.

To support heavy data mobility workloads without impacting administrative access, Purity defaults the next sequential pair of high-speed ports— eth2 and eth3 —to Replication services. These 10GbE, 25GbE, or 100GbE ports are meant to be cabled directly to the customer's redundant WAN links or replication switches. They carry all asynchronous snapshot transfers, continuous ActiveDR replication, and synchronous ActiveCluster traffic between arrays. While an Implementation Engineer can manually reassign these services using the purenetwork CLI suite if the customer requires a custom topology, utilizing eth2 and eth3 as the default replication interfaces remains the universally documented Pure Storage best practice for baseline installations. Ensuring these specific ports are properly patched into the designated replication VLANs prior to running the initialization scripts guarantees a smooth, error-free setup process.

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

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

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.

The puresupport command suite is used to manage and verify the connectivity between the FlashArray and Pure Storage Support (Pure1). Specifically, to test the Remote Assist functionality—which allows Pure Support to securely log in to the array for troubleshooting—the correct command is puresupport test.

While phonehome is a related concept (sending logs out), Remote Assist is a distinct inbound tunnel feature. purearray test pinghome is often confused with phonehome but is an older or specific test for the log sender. The puresupport test command runs a comprehensive check of the support channel connectivity, including the ability to establish the Remote Assist tunnel. If this test passes, the Implementation Engineer can be confident that Support can access the array if needed during or after the deployment.

=========

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

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

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

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

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

The customer should proceed via the Self-Service Upgrade (SSU) portal available on Pure1 Manage .

Pure Storage has transitioned significantly toward a self-service model for routine software upgrades to provide customers with greater flexibility and immediacy.

Pure1 Manage: This cloud-based management platform includes a "Software Lifecycle" or "Upgrade" widget. It automatically checks the array's health, compatibility, and readiness for various Purity versions.

Process: The customer can select the target Purity version directly in the portal. Pure1 then orchestrates the "Pre-Flight Checks" (Remote Audit) to ensure the array is healthy. Once passed, the Purity software is downloaded directly to the array, and the customer (or the engineer) can trigger the upgrade at their convenience without needing to schedule a specific window with a live Support engineer.

Invalid Options: Options A and B describe legacy or unsupported workflows. Customers do not manually download Purity ISOs to USB drives or run raw pureinstall CLI commands manually; these methods lack the automated safety checks and cloud-based verification provided by the SSU ecosystem.

When deploying Ethernet-based storage protocols like iSCSI or NVMe/TCP, establishing a healthy Layer 1 physical connection is the absolute first step. On standard Pure Storage FlashArray controllers (like the //X50 or //X70), the default on-board high-speed ports (ETH2 and ETH3) utilize SFP28 physical cages. These specific ports are hardware-designed to support 10GbE or 25GbE speeds depending on the inserted SFP+ or SFP28 transceiver.

In this scenario, a fundamental physical layer mismatch is occurring. The array ports are attempting to link at 10 Gb/s (using SFP+ optics), but the upstream SAN switch is operating natively at 40 Gb/s (which utilizes a physically larger QSFP+ form factor with four parallel 10G lanes). Auto-negotiation across mismatched optical form factors and lane architectures will almost always fail, resulting in a dead link showing 0 b/s.

An Implementation Engineer cannot magically "force negotiate" a 10G/25G SFP28 port on the array to run at 40G because the physical hardware simply does not support that bandwidth or encoding. Attempting to force the switch side (Option C) will also fail if the physical media doesn't match. The only correct, supported resolution is a hardware intervention: the engineer must replace the transceivers with the appropriate type . Typically, this involves using a QSFP-to-SFP adapter (QSA) on the switch side, or utilizing a specialized 40G-to-4x10G breakout cable to ensure both ends of the fiber are communicating using the exact same light wavelengths, lane counts, and physical port speeds.

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

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

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

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

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

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.

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 this specific "SAS-to-NVMe" media refresh during an upgrade, a SAS Swing Shelf is required.

The scenario describes a transition from a FlashArray//M (SAS-based chassis) to a FlashArray//X (NVMe-based chassis). The customer intends to retire the old SAS SSDs (the "SAS Chassis Data Packs") and move to new DirectFlash Modules (DFMs).

The Constraint: The old SAS drives physically cannot be inserted into the new //X NVMe chassis.

The Workflow: To migrate the data, the old SAS drives must be temporarily attached to the new //X controller as external capacity. Since they were originally internal chassis drives, they have no enclosure. Therefore, the engineer needs an empty SAS expansion shelf (Swing Shelf) to house these legacy drives.

Process:

Install the new //X chassis with the new DFMs.

Install the SAS Swing Shelf and populate it with the old SAS drives from the //M chassis.

Connect the SAS shelf to the //X controller (requires SAS connectivity).

The system sees the old data (external) and the new capacity (internal).

The system evacuates the data from the SAS shelf to the internal DFMs.

Once empty, the SAS shelf is removed.

A "DFM Swing Shelf" (Option A) would not help read the old SAS drives.

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.

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

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

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

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

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

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

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

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

Address/Netmask: The IP configuration.

Gateway: Routing information.

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

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

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

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

=========

A FlashArray support case should be opened before starting the installation (Option C).

Proactive Support: Pure Storage advocates for a proactive support model. Opening a case (often categorized as an "Install" or "Planned Event" ticket) prior to the engineer arriving onsite or beginning the physical work serves multiple purposes:

Notification: It alerts Pure Support that a new array is about to come online.

Validation: It allows Support to verify the serial number, entitlement, and ensure the array is ready to receive the latest Purity updates or patches immediately upon connection.

Remote Assist: It establishes a placeholder for the "Health Check" phase. Once the physical install is done, the engineer can immediately reference this existing case number when enabling Remote Assist, allowing a Technical Support Engineer (TSE) to quickly jump in and perform the final validation without the delay of ticket creation and routing.

Waiting until an issue arises (Option A) is reactive, and waiting until completion (Option B) delays the mandatory sign-off process.

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.

=========

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

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

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

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.

For a Non-Disruptive Upgrade (NDU) from a FlashArray//X to a FlashArray//XL , the upgrade kit typically contains 4 QSFP cables, 2 Mellanox cards, and 20 DFMD blanks (or modules) .

2 Mellanox Cards: The FlashArray//X (source) likely requires the installation of 100GbE RoCE adapters (Mellanox) into its controllers to establish the high-speed replication link with the new FlashArray//XL (which has 100GbE native). One card is installed per //X controller.

4 QSFP Cables: To ensure a redundant, high-bandwidth connection between the two arrays during the data migration phase, 2 cables are used per controller pair (CT0-to-CT0 and CT1-to-CT1), totaling 4 cables.

20 DFMDs (Blanks/Fillers): The FlashArray//X typically holds 20 DirectFlash Modules. The FlashArray//XL chassis has 40 slots. When the 20 data drives are physically moved from the //X to the //XL, the //XL will still have 20 empty slots. These must be filled with DirectFlash blanking modules (DFMD blanks) to maintain proper chassis airflow and thermal pressure. Thus, the kit includes these 20 fillers.

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

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

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

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

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

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

=========

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

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

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

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

=========

During the post-installation or upgrade validation phases of a Pure Storage FlashArray (or FlashBlade), ensuring that the storage system can communicate with the outside world is a mandatory requirement. Pure Storage relies heavily on its cloud-based management and predictive support platform, Pure1. The array continuously streams telemetry data, performance metrics, and hardware health alerts to Pure1 through a secure, outbound HTTPS connection.

Within the Purity operating system architecture, the internal daemon responsible for managing this critical outbound connection, handling proxy routing, and securely packaging the telemetry payloads is known as the Callhome Connection Manager , frequently abbreviated in system logs and CLI outputs as CCM . When an Implementation Engineer runs network diagnostic scripts or initial setup routines to verify outbound connectivity, the system will attempt to handshake with the Pure1 cloud infrastructure. If the output explicitly reads "Ping Successful with CCM", it serves as direct confirmation that the local controller has successfully navigated any local network firewalls or configured web proxies, authenticated its secure tunnel, and established a healthy connection to Pure1. This output does not relate to internal cross-controller links (which utilize Non-Transparent Bridge or NTB technologies via PCIe) nor does it indicate a connection to a Pure Fusion control plane or an ActiveCluster mediator.

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.

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.

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.

The FlashArray//XL supports 0 (zero) SAS expansion shelves for permanent capacity.

Architecture: The FlashArray//XL is architected exclusively for NVMe storage media. Its backend connectivity utilizes 100GbE RoCE (RDMA over Converged Ethernet) to connect to DirectFlash Shelves (DFS) . It does not possess the legacy SAS controllers or ports required to drive SAS expansion shelves.

Migration Exception: While a "SAS Swing Shelf" (containing legacy SSDs from an older array) might be temporarily attached during a specific Data-in-Place upgrade migration scenario, this is a transient state. In terms of supported operational configuration for storage capacity, the limit is zero. The platform relies entirely on DirectFlash Modules in the chassis and external DirectFlash Shelves.

Contrast: Older generations (FlashArray//M, FlashArray//X R1/R2) supported SAS shelves, but the //XL platform eliminates this protocol entirely in favor of end-to-end NVMe.

FlashArray File Services (FA File) brings unified block and file storage capabilities directly into the Purity operating system, allowing customers to provision high-performance SMB and NFS shares alongside their traditional Fibre Channel and iSCSI volumes.

Once the initial FA File networking (Virtual Interfaces) and DNS/Active Directory integrations are configured, the Implementation Engineer must actually create the file structures for the customer. In the Pure Storage Purity GUI, the logical hierarchy for file storage requires the administrator to first create a "File System," which acts as the top-level container, and then create "Directories" within it that will be exported to clients.

To manage, create, or modify these directories, the Implementation Engineer must navigate through the left-hand navigation pane to Storage > File Systems . Clicking into a specific File System reveals the "Directories" tab. From this central pane, the engineer can create new managed directories, apply specific export policies (defining which IPs or users have read/write access), and configure directory-level snapshot schedules. Option B (Settings > Access > Directory Services) is a common distractor, but that menu path is used exclusively for configuring the array's connection to Active Directory or LDAP for administrative login authentication, not for managing storage directories.

During the lifecycle of a Pure Storage FlashArray, Implementation Engineers and storage administrators frequently perform hardware non-disruptive upgrades (HWNDU), capacity expansions, controller replacements, or network reconfigurations. Because the FlashArray is inherently designed to aggressively monitor its own hardware sensors and software states, these administrative actions will naturally trigger a cascade of critical alerts. If left unchecked, the array's Call Home feature will immediately dispatch these alerts to Pure Storage Support (automatically opening support tickets) and blast emails to the customer's IT Operations teams, causing unnecessary panic.

To cleanly suppress these automated alerts during a planned event, the Implementation Engineer must utilize the puremaintenance command-line suite within the Purity operating system. By executing the specific command puremaintenance schedule array --timeout < timeout > , the engineer successfully flags the entire storage array as being in an active maintenance window. The --timeout parameter is crucial, as it dictates exactly how long the maintenance window will remain open (e.g., 2h for two hours) before the array automatically reverts to its normal, fully alerting state. This acts as a built-in safety mechanism, ensuring that if an engineer forgets to manually remove the maintenance tag after the upgrade, the array will not remain indefinitely silenced and exposed to unreported future failures. The other options presented either use incorrect command syntax or reference non-existent Purity CLI tools.

The Pure1 mobile app (available on iOS and Android) is a powerful, cloud-connected tool that allows storage administrators and engineers to monitor their fleet from anywhere in the world. Viewing array telemetry (like IOPS, latency, and bandwidth), monitoring capacity utilization, and managing support cases are all handled seamlessly through Pure1's secure cloud infrastructure. These features work perfectly fine over a standard cellular network or public Wi-Fi.

However, enabling a Remote Assist session is treated with a much higher level of security. Remote Assist opens a secure, reverse SSH tunnel directly from the array to Pure Storage Support, allowing them to perform troubleshooting or execute upgrades. To trigger this from the Pure1 mobile app, the command must be authenticated and sent directly to the array's local management IP interface—it does not pass blindly down from the cloud.

Because of this architectural security design, the mobile device must be connected to the internal company network (e.g., via a corporate VPN or internal corporate Wi-Fi network) that has routing access to the array's management subnet. This ensures the organization's existing firewall and security models are respected, preventing unauthorized external triggers of support tunnels.

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.

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

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

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

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

When configuring the network topology for a new Pure Storage FlashArray//XR4 deployment, the physical Ethernet ports on the rear of the controllers are rigidly mapped to default services by the Purity//FA operating system. This standardized mapping ensures that Implementation Engineers can reliably configure out-of-band management access before any advanced routing or high-speed data fabrics are established.

Across the entire FlashArray product line—including the modern //XR4 and //CR4 architectures—the first onboard 1GbE Base-T copper port, explicitly labeled eth0 , is always enabled and dedicated strictly to the management service by default.

This interface (eth0, along with its highly available partner eth1) is responsible for all non-disruptive administrative access. It handles the web-based GUI traffic (HTTPS), SSH terminal sessions, REST API calls, and the secure outbound tunnel to the Pure1 cloud for Call Home telemetry and Remote Assist. High-speed ports like eth2, eth4, or eth6 (which utilize SFP28 or QSFP optical transceivers) are defaulted to Replication or left unconfigured for frontend host I/O (iSCSI/NVMe-oF). An Implementation Engineer relies on eth0 being the default management port to connect their laptop during the initial serial console setup (puresetup) and validate network reachability.

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

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

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

=========

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 FlashArray//XR2 and //XR3 architectures utilize dedicated NVRAM modules to provide the non-volatile write cache necessary for acknowledging writes safely before they are destaged to flash. These chassis are equipped with multiple NVRAM bays (labeled NVB0 through NVB3).

For standard configurations, specifically the //X10, //X20, and //X50 models, the system requires a redundant pair of NVRAM modules to function. These are always installed in NVRAM bays 0 and 1 .

Bays 0 and 1 form the primary high-availability pair. If one fails, the other retains the data, and the system can continue to operate (though often in write-through mode or with alerts).

Higher-end models like the //X70 and //X90 populate all four bays (0-3) to provide the larger write buffer required for their higher throughput capabilities.

However, since the question asks which bays are always populated (i.e., the minimum requirement for the platform to function across the board), the answer is the foundational pair in slots 0 and 1. An Implementation Engineer must ensure these specific slots are populated first during any chassis maintenance or upgrade.

=========

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.

=========

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

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

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

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

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

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.

=========

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.

=========

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.

=========

Pure Storage differentiates its product lines based on the type of NAND flash used, optimizing for either performance or capacity/cost.

FlashArray//X uses TLC (Triple-Level Cell) flash for high performance and endurance. These modules typically have orange tabs.

FlashArray//C and FlashArray//E are designed for high-capacity, capacity-optimized workloads. They utilize QLC (Quad-Level Cell) flash.

QLC flash stores 4 bits per cell, offering higher density at a lower cost per terabyte, but with different endurance characteristics managed by the DirectFlash software. To help engineers and customers physically distinguish these modules, QLC DirectFlash Modules feature gray release tabs on the carrier. Identifying these tabs confirms that the correct media type is being installed into the capacity-oriented //C or //E chassis.

=========

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.

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.

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.

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.

=========

FlashArrays require outbound HTTPS connectivity to reach Pure1 for log uploads, phone home, and remote assist. In many enterprise environments, direct internet access is blocked, and traffic must be routed through an HTTP/HTTPS proxy.

To configure this setting in Purity via the CLI, the correct command is purearray setattr --proxy followed by the full proxy URL (including protocol and port). The setattr (set attribute) subcommand is the standard method for modifying array-wide configuration parameters like the array name, idle timeout, and proxy settings. The other command variations (puresetup proxy or purearray configure) are incorrect syntax for this specific operation. This configuration is often a critical step during the "Pre-Flight" or initial setup phase to ensure the array can "phone home" immediately upon deployment.

=========

A Pure Storage FlashArray is a highly available, dual-controller system. During the initial puresetup process, the Implementation Engineer assigns three distinct management IP addresses to the system: one physical IP for Controller 0 (ct0), one physical IP for Controller 1 (ct1), and one Virtual Management IP (VIP or vir0) .

According to official Pure Storage administration and implementation best practices, users should always connect to the GUI, CLI, and REST API using the Virtual Management IP. The Purity operating system utilizes an active/standby management plane. The VIP is designed to automatically float and bind itself to whichever controller is currently acting as the Primary node for management services.

If an administrator points their browser or SSH client directly to a physical controller IP (like CT0) and that controller happens to be the secondary node, they will either be redirected to the VIP, restricted to read-only access, or lose connection entirely if that specific controller is rebooting during a non-disruptive upgrade (NDU). By consistently using the Virtual Management IP, the customer ensures seamless, uninterrupted access to the array's administrative interfaces regardless of the underlying hardware state or active controller role.

When expanding capacity on a Pure Storage FlashArray, it is critical to understand the distinction between normal drive insertion states and hardware fault states. As established in previous deployment steps, when a standard, supported DirectFlash Module (DFM) is inserted into a healthy array, it typically enters an "unadmitted" state. This means the hardware is fully recognized, but the system is securely waiting for the administrator to manually claim the drives using puredrive admit.

However, if an Implementation Engineer inserts a new data pack and the puredrive list command reports the status strictly as "unrecognized," this indicates a deeper software-to-hardware mismatch.

The Purity//FA operating system relies on an internal hardware dictionary (including specific drivers and firmware profiles) to communicate with the custom NVMe flash modules. If a customer purchases a newly released, next-generation DFM (for example, a higher-density QLC drive or a newly manufactured DFM with an updated internal NAND controller), an older version of Purity simply will not know how to interact with it. Because the older OS lacks the required hardware definitions, it flags the drive as "unrecognized." To resolve this issue and proceed with the capacity expansion, the Implementation Engineer must first perform a non-disruptive upgrade of the Purity operating system to a version that officially supports the new drive's Bill of Materials (BOM).

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.

=========

On a FlashArray//XR2 or //XR3 , if a dedicated PCIe SAS HBA (Host Bus Adapter) is required for external shelf connectivity (expanding beyond the onboard SAS ports), it must be installed in Slot 1 .

The PCIe slot prioritization on the FlashArray//X R2/R3 controllers is strictly defined to ensure optimal performance and lane distribution:

Slot 0: Reserved primarily for frontend Host I/O cards (Fibre Channel or iSCSI/Ethernet). This slot usually connects to CPU 0 and offers high bandwidth for host traffic.

Slot 1: Designated as the primary expansion slot for backend connectivity (SAS cards for expansion shelves) or secondary Host I/O if no SAS expansion is needed.

Slot 2: On smaller models (X10/X20), this is often the only host I/O slot, but on the larger X50/X70/X90 chassis, it is used for additional Host I/O.

If an Implementation Engineer installs a SAS card in Slot 0, the system may fail to recognize the shelves correctly or may flag a configuration error, as the Purity software expects backend expansion traffic to route through the bus associated with Slot 1. Therefore, for SAS expansion cards, Slot 1 is the mandatory location.

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

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

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

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.

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.

To ensure that all volumes connected to a specific host are automatically protected, the Implementation Engineer should add the Host object as a member of the Protection Group (PGroup) .

Purity's protection policy logic allows for membership at different granularities:

Volume Membership: You can add individual volumes to a PGroup. However, if a new volume is provisioned and attached to the host later, it will not be protected until an admin manually adds it to the PGroup (making Option A and B manual, error-prone processes).

Host/Host Group Membership: By adding the Host entity to the Protection Group, Purity applies a policy inheritance rule. Any volume currently connected to that host—and crucially, any volume attached in the future —automatically inherits the protection policy (snapshot schedule, replication target) of that group. This "set and forget" configuration is the best practice for ensuring compliance and data safety without requiring manual intervention for every provisioning task.

Modern Pure Storage FlashArrays support unified block and file storage directly out of the box (often referred to as FA File). To utilize file protocols like SMB or NFS on the array, the Implementation Engineer must properly configure the networking interfaces to handle file-specific traffic.

Purity handles network traffic routing by assigning specific "services" to its Ethernet interfaces or Virtual Interfaces (VIFs). When creating or modifying a virtual network interface using the purenetwork CLI suite (or via the GUI), the engineer must explicitly define what type of traffic is allowed to traverse that interface.

To configure a subnet and virtual interface dedicated to File Services, the --service flag must be set to file. For example, a common command structure would look like:

purenetwork setattr --service file < interface_name >

Assigning the iSCSI service would strictly format the port to listen for block-level SCSI commands over TCP/IP, Replication would reserve the port for array-to-array snapshot transfers or ActiveCluster traffic, and Management would restrict the port to GUI/CLI administrative access. Only the file service type enables the necessary protocol daemons to export NFS shares and SMB directories out of that specific network port.

When implementing FA File services (Pure Storage's file services protocol support), the array must integrate with the customer's existing directory infrastructure (like Active Directory) for user authentication and permission management. By default, the FlashArray utilizes its management interface to perform DNS resolution and establish communication with domain controllers.

This design choice simplifies initial deployment because the management network is typically already configured with access to core infrastructure services like DNS and NTP. While the filevip (File Virtual IP) and its associated virtual interfaces (vif) are used for actual SMB/NFS data traffic between clients and the array, the control plane traffic for directory services and authentication lookups is routed through the management port (ct0.eth0/ct1.eth0 or the virtual management IP).

It is critical for Implementation Engineers to verify that the management network has the necessary firewall rules and routing to reach the customer's domain controllers and DNS servers. If the management interface is isolated on a dedicated out-of-band network without access to these services, the FA File directory service configuration will fail, even if the data interfaces (filevip) are correctly cabled and IP'd.

=========

FlashArray//X R4 (and the associated //C R4) models, introduced with the PCIe Gen 4 architecture, feature support for 64Gb Fibre Channel (FC) connectivity. The default Fibre Channel Host Bus Adapters (HBAs) and the accompanying SFPs shipped with this generation are 64Gb capable, marking a significant performance leap from the 32Gb standard of the R3 generation.

While the HBAs are backward compatible with 32Gb and 16Gb SAN infrastructures, the R4 platform is explicitly marketed and technically defined by its ability to drive 64Gb line speeds to match the increased throughput of the backend PCIe Gen 4 bus and DirectFlash Modules. For an Implementation Engineer verifying the bill of materials or configuring the switch ports, it is critical to know that the R4 optics are native 64Gb. If the customer's switch infrastructure is only 16Gb or 32Gb, the ports will auto-negotiate down, but the shipped default hardware is the 64Gb standard (Option C). Option A (16Gb) and Option B (32Gb) refer to the default standards for the older //M and //X R2/R3 generations respectively.

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.

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.