Pure Storage FlashArray-Implementation-Specialist Pure Certified FlashArray Implementation Specialist (FAIS) Exam Exam Practice Test

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

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

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

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

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

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

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

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.

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.

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.

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

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

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

=========

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.

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

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

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

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

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.

=========

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

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

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

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

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

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

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

During the preparatory phases of a FlashArray Hardware Non-Disruptive Upgrade (HWNDU), validating physical connectivity is a strict prerequisite. If an Implementation Engineer discovers that a DirectFlash Shelf (like SH9) is incorrectly cabled to CT0, the safest and most efficient remediation is to correct the cabling precisely during the physical replacement of that specific controller.

Option A (proceeding and fixing it after) is perilous because leaving the improper cabling in place could compromise backend redundancy when the partner controller assumes the full I/O load, potentially leading to a multi-pathing failure or data unavailability event during the NDU. Option B (rescheduling the entire upgrade) is an unnecessary overreaction that wastes time and resources, as the upgrade procedure itself provides the perfect window for correction.

When the Implementation Engineer initiates the failover and successfully takes CT0 offline to swap the hardware, all active I/O is safely routed through CT1. Because CT0 is completely powered down and physically isolated from the data path at this stage, the engineer can safely disconnect the miswired SAS or NVMe-oF cables and re-cable them correctly into the new CT0 hardware according to the official Pure Storage cabling matrix. This method ensures maximum redundancy is restored the moment the new controller boots, seamlessly resolving the issue without introducing any additional maintenance windows or risks.

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.

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

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

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

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.

=========

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

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

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

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

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

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

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

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.

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.

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

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.

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.

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

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

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

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

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.

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

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

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

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

When installing the first DirectFlash Shelf (DFS) on a FlashArray//XR2 or //XR3 utilizing the onboard or default mezzanine connectivity, the correct ports to use are ETH6 and ETH9 .

Hardware Layout: The FlashArray//XR2 and //XR3 utilize a specific Ethernet Mezzanine (EMEZZ) slot for backend connectivity to NVMe-oF shelves. This card typically enumerates its ports as ETH6 through ETH9 (a 4-port configuration).

Cabling Rule: To maximize physical separation and ensure redundancy across the internal ASIC lanes of the mezzanine card, standard cabling procedures for the first shelf dictate using the outer ports: ETH6 (Port 0) and ETH9 (Port 3).

Redundancy: This configuration (Port 0 and Port 3) is preferred over using adjacent ports (like 6 and 7) to reduce the risk of a single lane cluster failure affecting both connections to the shelf. The second shelf, if added later, would typically utilize the remaining ports (ETH7 and ETH8).

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

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

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

When performing a specific legacy upgrade from a FlashArray FA-405 to a FlashArray//X Series , the 2-Port InfiniBand card must be installed in PCIe Slot 3 of the target controller (CT1).

Upgrade Architecture: The legacy FA-400 series utilized InfiniBand (IB) for its high-speed cluster interconnect. The modern FlashArray//X series utilizes PCIe/NTB over an internal midplane or different interconnects. However, during a non-disruptive upgrade (NDU) or data migration where the new //X controller is temporarily clustered with the old FA-405 controller to transfer state and data, they must share a compatible link.

Slot Reservation: The FlashArray//X hardware guide and upgrade procedures strictly designate Slot 3 (the top slot on the riser in many //X chassis configurations) as the reserved location for this temporary InfiniBand interconnect card. Installing it in Slot 0 or 2 would conflict with the primary Host I/O or backend connectivity paths, potentially causing the controller to fail the upgrade pre-checks or preventing the cluster from forming.

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

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

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

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

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

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.

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

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

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

=========

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

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

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

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

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

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

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

=========

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

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

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

=========

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

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

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.

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

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

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

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

During the physical racking and stacking of a Pure Storage FlashArray, ensuring correct power delivery is a foundational step. The standard 3U FlashArray models—which include the //X10, //X20, //X50, //X70, and //X90—operate using highly efficient power supply units (PSUs) that do not require massive industrial power draws.

According to the official Pure Storage FlashArray Installation Guide, the standard accessory kit shipped with every new 3U array includes C13 to C14 power cables . The C13 end of the cable plugs directly into the C14 receptacle located on the power supplies at the rear of the array chassis, while the C14 end plugs into a standard C13 output receptacle on the datacenter's rack Power Distribution Unit (PDU).

It is important for an Implementation Engineer to differentiate this from the much larger FlashArray//XL platform. The 5U //XL chassis houses significantly more powerful components and up to 40 DirectFlash Modules. Because of its higher power requirements, the //XL relies on heavy-duty C19 to C20 power cables. However, for the standard FlashArray//X series referenced in this question, C13 to C14 is the correct and provided baseline standard.

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.

The puresetup initialization script automatically runs a series of network validation tests to ensure the array can reach default gateways, DNS servers, and Pure1. If the management network is not yet live or is air-gapped during the install, these tests will fail, potentially blocking the setup process.

To proceed with the initialization despite the missing network, the Implementation Engineer must append the --skip-management-connectivity-tests flag to the puresetup command.

This flag instructs the script to bypass the ping/DNS lookup checks on the management interface.

It allows the engineer to complete the array initialization (naming, IP assignment) so the array is "up" and ready for local config, with the understanding that full management connectivity will be established and verified later.

=========

The 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 FlashArray//XL features a robust 2+2 power supply unit (PSU) redundancy configuration. Unlike the smaller FlashArray//X chassis (3U), which typically utilizes two power supplies in a 1+1 redundancy setup, the FlashArray//XL utilizes a larger 5U chassis designed for higher performance and density, requiring a more substantial power infrastructure.

The //XL chassis is equipped with four physical Power Supply Units. These are configured to operate in an N+2 mode (effectively 2+2), meaning the system requires two PSUs to support the full electrical load of the chassis, while the other two provide redundancy. This architecture allows the array to survive the simultaneous failure or loss of input power to up to two power supplies without any interruption to service.

This design ensures maximum availability even in scenarios where an entire power grid feed (A-side or B-side) fails, or if multiple hardware components malfunction simultaneously. Options A (1+1) applies to the standard //X series, and Option C (3+1) is not a supported configuration for the FlashArray//XL. The 2+2 design is critical for maintaining the "Always-On" reliability standards required for the mission-critical workloads that the //XL platform supports.

Understanding the default network port assignments on a standard 3U Pure Storage FlashArray (which encompasses models like the //X10, //X20, //X50, //X70, and //X90) is a fundamental requirement for any Implementation Engineer. The rear of the controllers features a standardized set of integrated Ethernet ports that are logically predefined by the Purity operating system upon factory initialization.

The first two ports, explicitly labeled eth0 and eth1 , are 1GbE Base-T copper ports. These are strictly reserved and dedicated by default for management traffic (GUI, CLI, SSH, API, and Call Home telemetry to Pure1). They are not designed to handle high-throughput storage workloads.

The next two ports, eth2 and eth3 , are high-speed 10GbE/25GbE optical/Twinax ports. By default, Purity provisions these specifically for asynchronous and synchronous replication traffic (including ActiveCluster), as well as IP-based block storage protocols like iSCSI if the customer is not using Fibre Channel. Utilizing eth2 and eth3 ensures that heavy data mobility workloads have the required bandwidth and are physically isolated from lightweight management traffic. Ports like eth4 and eth5 (if present via PCIe expansion cards) are typically configured manually for additional frontend host I/O or File Services, rather than acting as the default replication interfaces.

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.

To verify the status, presence, and admission of a specific data pack, the correct command is puredrive list --pack CH0.BAY10 .

In the context of FlashArray geometry, a "Write Group" (RAID set) is formed by combining DirectFlash Modules. A "Wide Write Group" typically consists of 10 modules (a full data pack). When an engineer installs a standard 10-pack of drives (Bays 10-19), verifying that all 10 drives are successfully recognized and "admitted" confirms that the system has formed the intended wide write group.

The puredrive list command with the --pack argument filters the output to show only the drives in that specific pack. The engineer checks that all 10 drives are listed and their status is "healthy" or "admitted" . If fewer drives were admitted (e.g., only 5), it would indicate a "narrow" write group or a hardware issue.

Option A (find_drive.py) is a utility script used to physically locate a drive by blinking its LED, not to check logical RAID configuration.

Option B (puredb list drives) is an internal engineering command (puredb) that is generally not intended for standard field verification and may require root-level access. The puredrive command is the standard CLI tool for this validation.

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.

=========

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

The Pure Storage FlashArray//XL170 R5 is the highest-tier array in the //XL lineup, engineered specifically for maximum performance density, aggressive OLTP database consolidation, and massive throughput. Because of its incredibly powerful Intel processors and high-bandwidth PCIe Gen 4 architecture, it demands a specific minimum storage footprint. If an array has too few drives, the backend flash media becomes a bottleneck, effectively starving the controllers of I/O.

According to Pure Storage configuration limits and sizing tools, the minimum supported capacity requirement for an //XL170 R5 chassis is 135TB .

This minimum baseline is typically provisioned using three separate 45TB data packs (represented in official BOM configurations as 135TB-45/45/45/0). The //XL architecture relies exclusively on DirectFlash Modules with Distributed NVRAM (DFMDs). To properly distribute the write cache, maintain N+2 high availability across the flash media, and deliver the extreme IOPS expected of an //XL170, the chassis requires this robust baseline population of DFMDs. Attempting to deploy an //XL170 with a smaller capacity (such as 90TB) violates the performance sizing guidelines. Customers requiring smaller baseline capacities are generally steered toward the FlashArray//XL130 or the //X90 series.

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

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

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

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

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

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

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

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

Proper airflow and thermal management are critical for the reliability of high-density storage arrays. FlashArray chassis are designed with specific airflow baffles and cooling zones that rely on the drive bays being populated in a specific order.

When installing a new FlashArray with a single data pack (typically 10 drives), the Implementation Engineer must install the DirectFlash Modules starting in bay 0, filling from left to right .

Bay 0 is typically the leftmost slot (when facing the front of the array).

Filling slots 0–9 ensures that the first "cooling zone" is properly pressurized, forcing air through the populated modules and the chassis midplane correctly.

Leaving gaps (e.g., installing in slots 10–19 while 0–9 are empty) can disrupt the airflow path, potentially leading to hotspots or inefficient cooling for the controllers behind the backplane.

Additionally, the software enumeration of drives often expects contiguous population starting from the lowest index for logical clarity, though cooling is the primary physical constraint.

=========

Understanding the hardware architecture and proper drive population rules is critical during a Pure Storage FlashArray installation. FlashArray models generally utilize either standard DirectFlash Modules (DFMs) or DirectFlash Modules with distributed NVRAM (DFMDs).

DFMDs, primarily introduced with models like the FlashArray//XL, integrate non-volatile write caching directly into the capacity drives themselves, eliminating the need for dedicated NVRAM hardware modules. However, standard FlashArray models—such as the //X10, //X20, //X50, //X70, and //X90—use standard DFMs strictly for capacity. Because standard DFMs do not contain built-in NVRAM, these arrays rely heavily on specialized, dedicated NVRAM modules to safely acknowledge incoming writes and protect data in flight against unexpected power loss or controller failures.

To maintain absolute high availability and guarantee there is no single point of failure within the write cache, NVRAM is always mirrored across two separate physical modules. During the physical hardware installation of a non-DFMD array, the Implementation Engineer must populate the dedicated NVRAM bays located centrally on the chassis. According to official Pure Storage implementation guidelines, the primary pair of NVRAM modules must always be installed in the first two designated bays, which are explicitly labeled NVB0 and NVB1. Placing the modules in alternate or staggered bays (such as NVB0 and NVB2) violates the strict hardware population rules and will prevent the array from initializing.

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

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

Component Compatibility:

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

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

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

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.

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

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

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

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

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

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

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

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

Expansion Logic:

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

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

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

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.

=========

At the completion of an upgrade, the correct command to manually trigger the upload of the relevant logs is purearray phonehome --send-today .

Purpose: This specific argument (--send-today) instructs the array to bundle and upload all log files generated within the current 24-hour window. This is the standard procedure post-upgrade because it ensures that all logs capturing the pre-upgrade state, the upgrade process itself, and the immediate post-upgrade health checks are transmitted to Pure Support.

Verification: This allows the Support team to validate that the upgrade completed successfully and that no dormant issues were triggered during the controller failovers.

Syntax: Option A (purelogs) is not a valid command. Option B (--send-logs) is a generic approximation, but the specific "today" flag is the best practice command cited in upgrade checklists to avoid uploading gigabytes of historical data irrelevant to the immediate event.

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

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

Baud Rate (Speed): 115,200

Data Bits: 8

Parity: None (N)

Stop Bits: 1

Flow Control: None

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

During a hardware upgrade, physical components are often moved or handled, leading to potential connection issues. If a specific port (like CT0.ETH14) that is expected to carry traffic shows 0.00 b/s and "Link Down" or similar status immediately after the controller is initialized, the most likely physical issue is an improperly seated transceiver (SFP) or cable.

The standard troubleshooting hierarchy dictates checking Layer 1 (Physical) first. Therefore, the engineer should ensure the SFP in CT0.ETH14 is fully seated and re-seat it if necessary . SFPs can easily become slightly dislodged during the cable swap from the old controller to the new one. Checking the seating is a quick, non-disruptive step that resolves a high percentage of "dead port" issues during upgrades. Swapping to a management port (Option A) is invalid because management ports often have different speeds or configurations, and asking the customer to reboot hosts (Option B) is premature and potentially disruptive before ruling out the physical array connection.

=========

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.

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.

=========

This scenario highlights a critical architectural transition point within the Pure Storage FlashArray product line. The arrays utilize dedicated NVRAM modules to safely ingest and acknowledge incoming writes before destaging them to the capacity flash drives.

On the lower to mid-range models (such as the //X10, //X20, and //X50), the system requires only two NVRAM modules to maintain a highly available, mirrored write cache. These are physically installed in the central chassis slots NVB0 and NVB1. However, the higher-end, performance-heavy models (such as the //X70 and //X90) boast significantly more processing power and ingest bandwidth. To support these massive workloads without creating a cache bottleneck, the architecture mandates four NVRAM modules, filling slots NVB0, NVB1, NVB2, and NVB3.

Therefore, when performing an inter-generational, cross-model Hardware Non-Disruptive Upgrade (HWNDU) from an //X50 to an //X70 , the Implementation Engineer is traversing that architectural boundary. While performing the controller swaps, the engineer is strictly required to install two additional, newly shipped NVRAM modules into the previously empty bays NVB2 and NVB3. If they fail to add these modules, the new //X70 controllers will detect a cache hardware deficiency and refuse to initialize, halting the upgrade process. Options B, C, and D do not cross this 2-to-4 NVRAM threshold.

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

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

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

=========

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.