Free and Premium Pure Storage FlashArray-Implementation-Specialist Dumps Questions Answers

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

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

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

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.

This scenario reinforces the standard Pure Storage controller replacement methodology during an inter-generational Hardware NDU. The start_ndu controller-ndu script is a specialized internal tool explicitly designed to adjust system-level tunables on a newly inserted controller so that it can seamlessly integrate with a peer controller of a different hardware footprint (e.g., an //XR3 peer and an //XR4 or //XR5 new controller).

The Implementation Engineer must run this script before initializing CT0 (or CT1, depending on which side is currently being replaced). The exact required workflow dictates that the Purity operating system must first be installed onto the new controller's internal boot drives so the OS is present to modify. Once installed, the tunable script is executed from the command line.

Only after these HWNDU tunables are safely set can the engineer proceed to initialize the controller using puresetup, allowing it to sync its NVRAM securely and establish High Availability (HA) with the older surviving node. Attempting to initialize the controller before setting this tunable will cause the cluster's health checks to fail and reject the mismatched node, stalling the upgrade process.

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

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

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

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

The Pure Storage product portfolio is strategically segmented to address different tiering requirements in the modern datacenter. While the FlashArray//X and FlashArray//XL are optimized for absolute performance and ultra-low latency using Triple-Level Cell (TLC) flash and Storage Class Memory (SLC), the FlashArray//C and FlashArray//E lines are engineered specifically for capacity consolidation and tier-2 workloads.

To achieve massive storage density at a much lower cost per terabyte, the //C and //E models exclusively utilize Quad-Level Cell (QLC) flash architecture. QLC technology stores four bits of data per NAND cell, significantly increasing physical capacity compared to TLC, while the Purity operating system intelligently mitigates the inherent wear-leveling and write-amplification challenges traditionally associated with dense QLC media.

Because QLC and TLC DirectFlash Modules (DFMs) share the exact same physical U.2 form factor and slot seamlessly into the identical drive bays, Implementation Engineers must be able to visually distinguish them onsite to prevent accidentally mixing drive types within a single chassis. Pure Storage strictly color-codes the physical release latches on the drive carriers to prevent this mistake: QLC DFMs feature distinct gray tabs , whereas standard TLC DFMs feature blue tabs. Identifying the gray tabs ensures the engineer is working with the correct //C or //E capacity modules before proceeding with the physical admission process.

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

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

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

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

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

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

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.

=========

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

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

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

=========

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, or

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.

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.

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//XL170R5 is a high-performance, high-capacity enterprise storage system. To maintain its performance characteristics and data layout efficiency, Pure Storage enforces a minimum raw capacity requirement for new orders and installations.

For the //XL170R5 model, the minimum supported configuration is 115TB of raw flash. This is typically achieved through a specific population of DirectFlash Modules (e.g., twenty 5.5TB modules or a similar combination that meets the threshold).

Implementation Engineers must verify during the pre-installation site readiness review that the hardware delivered matches this minimum. Attempting to initialize an //XL170 with significantly less capacity (e.g., 90TB) would be an unsupported configuration, potentially leading to performance degradation or an inability to initialize the wide write groups required by the //XL architecture.

=========

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 FlashArray//XR2 and //XR3 (representing the FlashArray//X generation) utilize a standardized 3U (3 Rack Units) chassis form factor.

This 3U chassis is the foundation for the majority of the FlashArray//X line, including the //X10, //X20, //X50, //X70, and //X90 models. It is designed to be compact while providing sufficient airflow and space for the dual controllers, two data packs (up to 20 DirectFlash Modules), and power/cooling infrastructure.

Dimensions: Approximately 5.12 inches (13 cm) in height.

Rack Layout: Implementation Engineers must reserve 3U of contiguous space for the base controller chassis. If expansion shelves are included, they typically require an additional 2U each (for SAS or NVMe shelves).

Option B (4U) is not a standard height for current Pure Storage arrays. Option C (5U) refers to the FlashArray//XL , a larger, performance-optimized platform designed for maximum scale and density, which uses a significantly taller chassis to accommodate more expansion slots and power components. Therefore, for the specified R2/R3 X-series, 3U is the correct height.

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.

A "shelf evacuation" is a non-disruptive capacity consolidation feature. When a customer upgrades to denser flash modules or decommissions older hardware, the Purity operating system transparently migrates all active data blocks off the target DirectFlash Shelf and redistributes them onto the remaining chassis capacity.

Once the GUI and CLI report that the evacuation is 100% complete and the drives are officially empty, the physical data migration is done. However, the Implementation Engineer cannot simply power off the shelf and rip out the cables. The FlashArray's internal database and topology map still retain historical references, WWNs, and hardware associations to that specific shelf and its empty drive bays.

To cleanly purge the shelf from the cluster's active topology and prevent persistent "missing hardware" alerts, Pure Storage Support must execute restricted, backend completion commands (such as the hidden purehw shelf remove script). Because these commands are locked behind advanced engineering privileges, the onsite Implementation Engineer must explicitly Enable Remote Assist (RA) . Remote Assist opens a secure, outbound SSH tunnel from the array's Callhome Connection Manager directly to the Pure Storage support cloud, allowing the remote engineer to log in, run the cleanup scripts, and give the onsite engineer the final green light to physically disconnect the hardware.

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.

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

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

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

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

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

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

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.

The FlashArray//XL chassis is designed with specific PCIe lane allocations to support high-performance host I/O and backend connectivity. The 4-Port Fibre Channel (FC) cards are high-bandwidth devices that require x16 PCIe lanes to function at full line rate without oversubscription.

In the FlashArray//XL architecture, PCIe slots 3 and 8 are designated x16 slots capable of supporting these dense 4-port host interface cards. Other slots, such as slot 5 or slot 2, may be x8 slots or reserved for other functions (like the backend SAS/Ethernet fabric or offload engines like the DCA), and thus may not physically accept or electrically support the 4-port card variant.

Implementation Engineers must adhere strictly to the slot map provided in the hardware guide. Installing a 4-port card into an unsupported slot (like an x8 slot) could lead to the card not training, the array failing to boot, or the card operating at reduced bandwidth, severely impacting host performance. Verifying the BOM and slot map for Slots 3 and 8 ensures the correct electrical and thermal environment for these critical host-facing components.

=========

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

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

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

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

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

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

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

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

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.

=========

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.

Following any planned maintenance event—such as a software upgrade, controller replacement, or network reconfiguration—it is a mandatory implementation step to verify that the FlashArray has successfully restored its secure outbound management connectivity to Pure Storage cloud services (Pure1).

To execute this validation on a FlashArray, the Implementation Engineer must use the purearray test command suite. Specifically, running a command like purearray test phonehome or purearray test with diagnostic flags forces the array's Callhome Connection Manager (CCM) to immediately generate and transmit a heartbeat payload to the Pure1 cloud infrastructure. If the network routing, DNS, and firewall rules are functioning correctly post-maintenance, the CLI will return a success message confirming that the payload was received by Pure Storage.

Note for clarity: While puresupport test (Option C) is a valid command within the Pure Storage ecosystem, it is strictly used on the FlashBlade (Purity//FB) operating system, not on block-optimized FlashArrays (Purity//FA).

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

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

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

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

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

=========

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

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

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

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

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.

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.

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.

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

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

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

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

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

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

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

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

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

The FlashArray//XL series (such as the XL130R5) utilizes a modern backend connectivity architecture for its expansion shelves, specifically the DirectFlash Shelf (DFS). Unlike older generations that might have used SAS (Serial Attached SCSI) for shelf connectivity, the //XL architecture relies on high-speed Ethernet with RoCE (RDMA over Converged Ethernet) to communicate with external media shelves. This ensures that the NVMe drives in the shelf perform with the same low latency as those in the head unit.

To attach a DirectFlash Shelf to a FlashArray//XL130R5, the chassis must be populated with specific PCIe interface cards designated for shelf back-end connectivity. The correct part for this is the FA-XL-100G Ethernet/RoCE 2-Port card. This card provides the necessary 100 Gigabit Ethernet bandwidth and RoCE protocol support required for the NVMe-oF (NVMe over Fabrics) backend fabric that Pure Storage uses.

It is crucial to distinguish this from host-facing cards. While an "iSCSI/RoCE" card exists, the shelf connectivity specifically utilizes the "Ethernet/RoCE" designation in the BOM to differentiate backend fabric ports from frontend host ports. The 200G options are generally reserved for host connectivity or inter-array clustering in specific high-performance setups, but the standard validated card for connecting the DFS to the //XL130R5 is the 100G Ethernet/RoCE adapter. Verifying this line item on the BOM prevents onsite delays where the engineer might otherwise find themselves with incompatible ports for the expansion shelves.

After a controller upgrade or any maintenance that involves path failovers, it is critical to verify that the host multipathing software has restored connectivity to all paths and that I/O is being distributed correctly. The specific command to validate this in Purity is purehost monitor --balance .

purehost monitor --balance : This command provides a real-time view of I/O statistics per initiator (host path). It highlights imbalances where one path might be taking zero traffic while others are overloaded, which typically indicates a pathing configuration issue, a bad cable, or a host that has not correctly rediscovered the path after the controller reboot.

purehost list simply displays configured hosts, not live performance data.

pureport list displays the status of array ports but does not show the per-host I/O distribution required to verify "balance."

=========

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.

A valid transfer path for re-using iSCSI cards during a controller upgrade is from a FlashArray//XR2 to a FlashArray//XR3 (Option A).

Hardware Continuity: The FlashArray//XR2 and //XR3 generations share a high degree of physical component compatibility, particularly regarding PCIe form factors and supported interface cards.

Upgrade Workflow: When performing an "Intra-Series" upgrade (refreshing just the controllers from R2 to R3 to gain CPU performance), the existing I/O cards (Fibre Channel or iSCSI) from the R2 chassis can typically be transferred directly into the new R3 controllers.

Legacy Limitations: Migrating cards from a much older FlashArray//M (Option B or C) is generally restricted. The //M series often used older generation PCIe cards or different form factors (like onboard risers) that are not validated or physically compatible with the modern PCIe slots found in the //X series. Therefore, for //M to //X upgrades, new I/O cards are usually required, whereas R2 > R3 supports reuse.

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.

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

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

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

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.

=========

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.

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

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

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

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

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

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

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

=========

On a FlashArray//X20 (R2 or R3) , the default Fibre Channel configuration is a 2-port FC card installed in Slot 2 .

The FlashArray//X hardware architecture differentiates slot usage based on the controller model:

Entry Level (X10/X20): These controllers have a limited number of PCIe lanes and slots available for user expansion. Slots 0 and 1 are often utilized by internal system components or reserved. Therefore, the primary Host I/O card (FC or iSCSI) is standardly installed in Slot 2 . Additionally, due to the entry-level positioning, the 2-port card is the standard default (though 4-port is supported).

Performance Level (X50/X70/X90): As seen in previous questions, these models prioritize Slot 0 for Host I/O and typically default to 4-port cards.

The distinction is critical for Implementation Engineers to ensure they are cabling the correct ports. For an X20, cabling Slot 0 (if a port is even visible) would be incorrect; the active host ports are in Slot 2.

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.

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.

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.

=========

The pureadm command suite is the primary CLI tool used by Implementation Engineers and Support to manage the Purity operating environment's services and high-availability states. After a controller reboot—whether part of a hardware replacement, NDU, or fresh install—it is critical to verify that the Purity software stack has initialized correctly and that all sub-services (such as the I/O handling process, management daemon, and scut) are running.

The specific command pureadm list is the correct syntax to display a summary of the Purity services and their current status (e.g., running, stable, or stopped) on the local controller. This command provides a clean, immediate view of the service stack's health. If the output shows all expected services as "running," the engineer can confirm the controller has successfully rejoined the cluster and is ready to handle operations.

While pureadm alone might print help text and pureadm status is often a valid guess for other systems, the strict syntax for FlashArray implementation verification relies on pureadm list. This step is a standard part of the "Health Check" procedures found in upgrade guides. Failing to verify service status before proceeding (e.g., failing over to the other controller) could lead to an outage if the rebooted controller hasn't actually fully started its data services. Therefore, pureadm list is the validation checkpoint before declaring the controller healthy.

=========

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.

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

The correct default configuration is:

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

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

PCIe Slot 6: DirectCompress Accelerator (DCA).

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

=========

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.

Adding an external DirectFlash Shelf (DFS) or a legacy SAS Expansion Shelf to a Pure Storage FlashArray requires precise physical cabling to ensure backend high availability. Because the controllers utilize an active/active backend topology—where both controllers must maintain redundant loops to every single capacity shelf—a single misplaced cable can cause a severe hardware fault.

Once the physical installation is complete, the Implementation Engineer must definitively validate the topology before handing the array over to production. To do this, they log into the local KVM console or SSH session using the restricted puresetup account. From here, the official Pure Storage post-installation procedure dictates running two specific Python validation scripts: storage_view.py enclosures and storage_view.py config .

While both are used, storage_view.py config is the primary command utilized to map the specific SAS or NVMe-oF (RoCE) port bindings. The script actively polls the physical ports on the rear of the controllers and traces the loops down through the I/O Modules (IOMs) on the shelves. If the cabling is flawless, the CLI will explicitly return: "No errors detected." If a cable is crossed (e.g., Controller 0 plugged into IOM 1 instead of IOM 0), the script will instantly flag the topology mismatch, allowing the engineer to correct it on the spot.

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

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

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

=========

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.

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.

=========

FlashArray models differ in their NVRAM requirements based on their performance tier and throughput capabilities. Lower and mid-range models (like the //X10, //X20, and //X50) typically operate with two NVRAM modules installed in slots 0 and 1. However, high-performance models (like the //X70 and //X90) require double the NVRAM buffer to handle the increased write I/O bandwidth, necessitating four NVRAM modules (populating slots 0, 1, 2, and 3).

When performing a Data-in-Place Upgrade (NDU) from a FlashArray//X50R3 to a FlashArray//X70R4 , the chassis remains (or is upgraded in a way that preserves data), but the new controller configuration shifts from a "2-NVRAM" requirement to a "4-NVRAM" requirement. Therefore, as part of the physical upgrade procedure, the Implementation Engineer must install two additional NVRAM modules into slots 2 and 3 of the chassis to support the new //X70 controllers.

If these modules are not added, the new //X70 controllers will detect an "insufficient hardware" condition and fail to boot or initialize the Purity software properly. This step is unique to upgrades crossing the boundary between mid-range and high-end models.

=========

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.

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.

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

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

Key Design Features: The 5U height accommodates:

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

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

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

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

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

During the initialization phase of a new Pure Storage FlashArray, the Implementation Engineer executes the puresetup newarray (or puresetup array) command via a local serial console connection. This interactive script prompts the engineer for foundational network parameters, including the management IP addresses (vir0, eth0, eth1), subnet mask, default gateway, DNS servers, and NTP servers.

By default, the puresetup utility contains built-in safety mechanisms. As soon as the IP parameters are entered, the script actively attempts to ping the provided default gateway, resolve external hostnames via the provided DNS servers, and synchronize time with the NTP targets. If the customer's top-of-rack (ToR) switches are not yet configured, the cables are unpatched, or the array is being pre-staged in a lab completely isolated from the production network, these validation tests will inevitably fail, causing the setup script to hang or reject the configuration.

To intentionally bypass this validation and force the array to accept the network parameters without testing them, the Implementation Engineer must append the --skip-network-tests flag to the setup command. Executing puresetup newarray --skip-network-tests allows the system to save the configuration to the internal database and logically initialize the cluster. The array will bring the management interfaces online locally, allowing the engineer to connect via the GUI or SSH as soon as the physical network is eventually plugged in and routed.

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

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

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

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.

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.

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.

When upgrading PurityOS on a Pure Storage FlashArray, the upgrade package file (.ppkg) is heavily compressed but still quite large, typically ranging between 6GB and 12GB depending on the version. Often, Implementation Engineers use a USB flash drive to transfer these upgrade files directly to the array's controllers, especially in dark sites where network-based file transfers are restricted.

However, standard USB flash drives are usually formatted with the FAT32 file system to ensure broad compatibility across different operating systems. FAT32 has a strict maximum file size limit of 4GB. Because the single Purity .ppkg file exceeds this limitation, engineers must split it into smaller chunks (usually using the Linux split -b command, which generates sequential files with suffixes like aa, ab) before copying them to the USB drive.

Once the split files are successfully transferred into the /home/puresetup/ directory on the FlashArray controller, they must be properly reassembled into the original, functional .ppkg binary. Because Purity runs on a custom Linux kernel, standard Linux CLI utilities apply here. The correct and officially supported method to achieve this is using the cat (concatenate) command. By running cat with the wildcard * on the split file names, the system sequentially reads the chunks in alphabetical order and redirects ( > ) the binary output to recreate the single, unified .ppkg file. Using join, tar, or zip will either fail to execute or corrupt the binary package entirely.

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.

=========

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.

=========

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.

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

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

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

Complex upgrades that involve both removing old capacity (evacuation) and replacing controllers (hardware NDU) require a "checkpoint" with Pure Storage Support to ensure data safety.

The correct procedure dictates contacting support after removing the fully evacuated drives but before proceeding with the hardware NDU .

Why? Once the old drives are physically removed, the array's configuration state has changed. Support needs to verify that the evacuation was 100% successful, that no stale objects or pointers to the removed drives remain in the database, and that the system is fully healthy and redundant.

Proceeding directly into a controller reboot (NDU) without this verification could lead to issues if the array still "thinks" it needs the removed drives, potentially causing a boot failure or data unavailability during the controller failover.