Pure Storage FlashArray-Implementation-Specialist Dumps

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

=========

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

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

Command Syntax:

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

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

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

The FlashArray//XL series (specifically the //XLR5 in this context) utilizes a 100 Gigabit Ethernet-based back-end fabric to communicate with DirectFlash Shelves (DFS). This connection relies on the RoCE (RDMA over Converged Ethernet) protocol to ensure low-latency access to the external NVMe modules.

The specific PCIe interface card validated for this connectivity is often labeled in the Bill of Materials (BOM) or configuration guides as the 2-Port 100GbE iSCSI/RoCE card (or simply the 100GbE Ethernet/RoCE card depending on the specific firmware/labeling revision). Crucially, it must be a 100GbE capability card.

The //XL platform standardized on 100GbE for its shelf interconnects, moving away from the 50GbE used in some previous generations of the //X series. The 200GbE cards are typically reserved for high-speed host connectivity or clustering, not the standard shelf loop. Therefore, ensuring the BOM includes the correct 100GbE RoCE-capable cards is essential for successful shelf detection and operation during installation.

ActiveCluster, Pure Storage's synchronous replication solution for zero RPO/RTO, currently supports a maximum of 2 arrays in a single active-active relationship (often referred to as a "Pod").

Architecture: The ActiveCluster architecture is strictly designed as a 1:1 synchronous pairing between two FlashArrays. This allows both arrays to serve reads and writes for the same volumes simultaneously.

Stretched Clustering: The limit of two arrays ensures that the synchronous acknowledgement (ACK) process for writes remains performant and manageable over the inter-site link. Adding a third array to the synchronous loop would exponentially increase write latency and complexity.

3-Data Center Configurations: While you can configure a "3DC" architecture, this involves one ActiveCluster pair (2 arrays) replicating asynchronously to a third, standalone array (ActiveCluster + ActiveDR or Async). However, the synchronous ActiveCluster domain itself never exceeds 2 arrays.

After a complex operation like a Hardware Non-Disruptive Upgrade (HWNDU), the Purity health services may occasionally stall or report generic errors like "health not responding." Standard alert commands (purealert list) might be empty or show generic "service unavailable" messages because the alerting service itself depends on the health system.

To troubleshoot this, the Implementation Engineer should dig deeper into the system's internal message log using puremessage list --open --hidden .

puremessage accesses the raw message bus of the array, which captures lower-level events than standard alerts.

--hidden is the critical flag here; it reveals internal system messages that are typically suppressed from the standard user view to avoid noise.

These hidden messages often contain the specific error codes or service failure reasons (e.g., "timeout waiting for daemon X") that explain why the health status is hanging. Providing this output to Pure Support significantly accelerates the root cause analysis. purearray diagnose is not a standard command for this purpose, and purealert watcher is for configuring notification recipients, not viewing log contents.

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

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

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

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

=========

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

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

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

=========

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.

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.

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.

When deploying File Services (often referred to as FA File) on a Pure Storage FlashArray, adhering to strict networking best practices is critical for ensuring enterprise-grade high availability and performance. Unlike basic management interfaces, which can technically operate on a single connection without disrupting data flow, data-serving interfaces demand robust redundancy. Therefore, the minimum requirement for deploying the file-services interface is dedicating at least 2 physical Ethernet ports per controller (for example, eth2 and eth3).

These dedicated physical ports are logically aggregated into a bonded interface using the Link Aggregation Control Protocol (LACP). LACP provides two distinct benefits: link redundancy and bandwidth aggregation. From a redundancy standpoint, if a single physical port, twinax cable, optical transceiver, or even the upstream Top-of-Rack (ToR) switch fails, the file traffic seamlessly fails over to the surviving port within the bond without disrupting active SMB or NFS client sessions. From a performance standpoint, multiple ports allow the array to distribute the file protocol workload more effectively. Attempting to configure File Services with zero dedicated ports or only a single physical port per controller violates Pure Storage implementation guidelines, creates a severe single point of failure, and will trigger persistent health alerts within the Purity operating system until the required redundancy is established.

The FlashArray//XR4 architecture fundamentally changed how external capacity is attached compared to older SAS-based or early NVMe platforms. Because DirectFlash Shelves (DFS) utilize massive 100GbE RDMA over Converged Ethernet (RoCE) for their backend loops to maintain NVMe-level performance, specific port and slot assignments are heavily regulated.

On an //XR4 model (such as the //X70 R4 or //X90 R4), the controllers feature dedicated, integrated 100GbE ports on the motherboard (specifically eth18 and eth19) which are strictly reserved for the first DirectFlash Shelf loop.

However, when an Implementation Engineer needs to install a second DirectFlash Shelf, the integrated onboard ports are already fully saturated. Pure Storage does not support daisy-chaining NVMe-oF RoCE shelves in the same manner as legacy SAS enclosures. Instead, a new dedicated backend fabric loop must be established. To accomplish this, the engineer must install an additional 100GbE RoCE PCIe expansion card. According to the official //XR4 PCIe Slot Population Matrix, the designated location for this secondary backend expansion card is PCIe Slot 4 . Installing the card into other frontend-designated slots (like Slot 0 or Slot 3) will trigger a topology mismatch during the array's pre-flight hardware checks and prevent the new shelf from initializing.

On a FlashArray//XR2 or //XR3 equipped with a 4-port Fibre Channel card in Slot 1 , the interfaces are named FC4, FC5, FC6, and FC7 .

The port enumeration logic on FlashArray controllers follows a sequential order based on the PCIe slot number:

Slot 0: This is the first PCIe slot. If a 4-port card is installed here (which is typical for the primary host I/O card), it claims the first block of names: FC0, FC1, FC2, and FC3 .

Slot 1: This is the second PCIe slot. A 4-port card installed here continues the sequence immediately after Slot 0. Therefore, it claims FC4, FC5, FC6, and FC7 .

Slot 2: Any card here would start at FC8 (if the previous slots are 4-port).

Option A describes the mapping for Slot 0. Option C describes a non-standard mapping that skips integers or assumes a different starting point. Correctly identifying these interface names is crucial for zoning (SAN configuration) and creating the correct host port definitions during the implementation.

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

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

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

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

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

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

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

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.

Drive or shelf evacuation is a resource-intensive, background data mobility process within the Purity operating system. When an Implementation Engineer issues an evacuation command via the CLI (e.g., puredrive evacuate) or the GUI, the array begins transparently reading data blocks from the targeted DirectFlash Modules, recalculating parity, and destaging those blocks onto the remaining free capacity in the chassis or a connected swing shelf.

According to strict Pure Storage Implementation guidelines, only one evacuation process can be actively running on a FlashArray at any given time . The system architecture does not support queuing multiple, simultaneous drive or shelf evacuations, nor does it allow an administrator to arbitrarily inject new drives into an active evacuation job.

If an engineer attempts to issue a second evacuation command while the first is still running, the Purity operating system will immediately reject the command and return an error stating that an evacuation is already in progress. While it is technically possible to cancel an evacuation, doing so forces the array to halt its progress and leaves the data fragmented across the old and new drives, wasting time. The only supported and safe method is to let the current evacuation reach 100% completion, physically remove the evacuated drives, and then initiate a completely separate, new evacuation job for the second data pack.

FlashArray controllers operate in an Active/Active high-availability cluster. Each controller (CT0 and CT1) has its own physical IP address for hardware-level management. However, Purity configures a Virtual IP (VIP) that floats between the two controllers.

The Virtual management IP is the recommended address for all administrative access, including the GUI, CLI, and API integrations. Using the VIP ensures High Availability (HA) for management sessions. If an Implementation Engineer were to log in directly to CT0's IP and CT0 subsequently rebooted (e.g., during an NDU or failure), the management session would be disconnected.

By contrast, the VIP automatically fails over to the surviving controller (CT1) in the event of a disruption, allowing the management session (and the GUI) to remain accessible. This abstraction layer simplifies administration, as the user does not need to know which controller is currently "primary" for management tasks. Direct controller IPs are typically reserved for specific hardware troubleshooting steps where accessing a specific node is required.

=========

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.

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.

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.

=========

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.

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

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

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

The Solution (Option B):

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

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

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

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

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

When an Implementation Engineer or storage administrator needs to configure the foundational networking for array-to-array replication, it is essential to distinguish between configuring the network interfaces and configuring the replication partnerships .

To set up the IP addresses, subnet masks, gateways, and assign the replication service to specific Ethernet ports (such as eth2 and eth3), the user must navigate to Settings > Network in the Purity GUI. This section of the interface is strictly dedicated to managing the physical and virtual network topology of the array. Here, the engineer defines which physical ports are allowed to handle replication traffic, ensuring it is isolated from frontend host I/O or management traffic.

It is a common misconception to navigate to "Storage > Array Connections" for this step. However, the "Array Connections" tab is used after the network settings are fully configured. "Array Connections" is where the administrator actually enters the Connection Key to establish the synchronous (ActiveCluster) or asynchronous replication link between two fully networked arrays. Therefore, the foundational IP configuration must always be completed first under the Settings > Network tab.

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.

=========

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 FlashArray//XR4 introduces a new hardware platform architecture (internally codenamed or associated with "Cobalt" components for its BMC and chassis management). During the manufacturing and initial deployment phase, specific validation scripts are used to ensure the platform hardware is correctly initialized before the Purity Operating Environment takes over.

For a new install of a FlashArray//XR4, the Implementation Engineer is often required to run cobalt check . py (or cobalt_check.py).

This engineering-level Python script queries the Baseboard Management Controller (BMC) and internal sensors to verify that the chassis components, fans, and power delivery systems are reporting "Healthy" status specifically for the R4 architecture.

Running this before puresetup prevents the setup process from failing midway due to a hardware initialization error. It acts as a "pre-flight" hardware validation specific to the R4 generation's new chipset and management subsystem.

=========

Standard enterprise data center power distribution units (PDUs) typically use C13 or C19 outlets. The FlashArray//X series power supplies utilize C14 inlets (the male connector on the chassis side). Therefore, the standard accessory kit included with a FlashArray//X ships with C13 to C14 power cables.

The C13 connector plugs into the array's power supply (matching the C14 inlet), and the C14 connector on the other end is designed to plug into a standard rack PDU (which typically has C13 outlets). This is the industry-standard "jumper cord" for rack-mounted server and storage hardware.

It is important for the Implementation Engineer to verify this during the pre-install phase. If the customer's facility uses non-standard PDUs (like those with C19 outlets or wall-style plugs), the standard kit cables will not fit, and the engineer must ensure the correct cables were ordered separately or provided by the customer. However, for the exam and standard BOM validation, the correct answer is the ubiquitous C13 to C14 cable type.

=========

After configuring the management network and proxy settings, it is essential to validate that the FlashArray can successfully transmit logs and telemetry to the Pure1 cloud. The specific command designed to trigger a manual test of this "Phone Home" functionality is purearray phonehome test .

purearray phonehome test : Initiates a test cycle where the array attempts to resolve the Pure1 endpoint, establish a secure connection, and send a sample payload. Success here confirms that DNS, firewall rules, and proxy settings are correct for outbound telemetry.

puresupport phonehome: This is often used to manually send logs (e.g., puresupport phonehome --send), but the test syntax is specifically under purearray.

purearray test pinghome: This is not a valid standard command for this specific validation.

Using the correct command ensures the engineer receives a clear "Success" or "Failure" message to sign off on the installation checklist.

=========

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.

Establishing a serial console session is a fundamental step for initializing a new FlashArray or troubleshooting boot issues. To successfully communicate with the FlashArray controllers via the DB9 or Micro-USB serial port, the terminal emulator (such as PuTTY or TeraTerm) must be configured with specific parameters.

The verified standard settings for all modern FlashArray controllers are:

Baud Rate : 115,200 (This is faster than the legacy 9600 standard used on older network gear).

Data Bits : 8

Parity : None (N)

Stop Bits : 1

Flow Control : Xon/Xoff (Software flow control is preferred over hardware RTS/CTS).

Configuring these settings incorrectly (e.g., wrong baud rate) will result in garbled text ("garbage characters") or a completely blank screen when connecting to the console, preventing the engineer from running the puresetup initialization script.

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.

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

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

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

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.

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

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.

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.

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.

DirectMemory Modules (DMMs) are Storage Class Memory (SCM) drives used in FlashArrays to provide a high-speed read cache (DirectMemory Cache). In the FlashArray//XL architecture, these modules provide significant performance benefits for read-intensive workloads.

A fundamental configuration rule for DMMs on the //XL platform is that they cannot be installed in a DirectFlash Shelf (DFS) .

DMMs must be installed directly into the controller chassis (the head unit) to leverage the lowest possible latency connection to the CPU and memory complex.

The external backend fabric that connects to the shelves (even though it is NVMe-oF/RoCE) adds a minute amount of latency that negates the extreme speed advantage of SCM. Therefore, Purity only supports DMMs when they are local to the controllers.

DMMs share the same physical form factor and slots as standard DirectFlash Modules (DFMs) in the chassis but are typically prioritized for specific slot ranges (e.g., the first few slots) for thermal and bus management.

=========

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.

=========

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

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

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

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

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

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.

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

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

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

Address/Netmask: The IP configuration.

Gateway: Routing information.

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

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

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

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.

A valid transfer path for re-using Fibre Channel (FC) cards during a controller upgrade includes moving cards from a FlashArray//M to a FlashArray//XR2 or //XR3 .

The FlashArray hardware compatibility matrix supports the migration of specific legacy hardware components to ensure investment protection for customers. The 16Gb Fibre Channel PCIe cards originally deployed in FlashArray//M controllers are physically and electrically compatible with the PCIe risers found in the FlashArray//X R2 and R3 generations.

When performing a "Stateless" upgrade (where the chassis/controllers are replaced but data drives or cards might be retained), the Implementation Engineer can physically transfer these FC HBAs from the retiring //M chassis into the new //X chassis (assuming the target chassis has the appropriate open slots and the cards meet the minimum speed requirements, typically 16Gb or 32Gb). Option B is the most comprehensive correct answer recognized by the exam, confirming that the //M series cards can land in either of the specified //X generations (R2 or R3). Option C is also physically possible but the specific exam context for "reuse" highlights the inter-generational leap from M to X.

, formatted as requested.

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

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

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

=========

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.

=========

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.

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

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

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

Calculating rack space requirements is a fundamental pre-installation task. The FlashArray//XL series features a larger chassis than the //X series to accommodate its increased power, cooling, and DirectFlash capabilities.

The FlashArray//XL Chassis itself occupies 5 Rack Units (5U) .

A standard DirectFlash Shelf (DFS) occupies 2 Rack Units (2U) .

In this scenario, the customer is installing one //XL chassis and two DFS shelves.

Calculation:

1 x //XL Chassis (5U) = 5U

2 x DirectFlash Shelves (2U each) = 4U

Total = 9U.

Therefore, the Implementation Engineer must verify that there are at least 9 contiguous Rack Units available in the cabinet. Standard best practice also suggests placing the shelves immediately above or below the controller chassis to accommodate the 3-meter maximum cable length for the backend fabric, so these 9U should ideally be in a single block.

=========

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

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

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

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

=========

When performing a Hardware Non-Disruptive Upgrade (HWNDU) or preparing for a Purity software upgrade, the Implementation Engineer must log in with a user account that has full administrative privileges to execute upgrade commands, run health checks, and manage the array state.

The pureuser account is the standard administrative superuser for the FlashArray. It is used for all day-to-day administration and maintenance tasks, including initiating upgrades via the CLI (pureinstall or pureupdate commands) and verifying system health (purearray health, pureadm list). The puresetup account is strictly for initial array initialization (setting IPs and array name) and is disabled or restricted once the array is up and running. pureinstall is a command, not a user account. Therefore, pureuser is the correct authenticated session required to manage the upgrade process.

=========

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.

Data evacuation is a background process used to move data off specific physical media (like a shelf or data pack) so it can be removed safely. Purity is designed to handle dynamic changes to evacuation requests efficiently.

If an evacuation is already running and additional hardware needs to be evacuated, the Implementation Engineer does not need to stop the current job or wait for it to finish. The correct procedure is to issue a new evacuation command specifying the additional packs or shelves. Purity will intelligently update the existing background job to include the new targets, queuing the data movement logic to ensure all specified hardware is cleared. This "add-to-flight" capability saves time and administrative overhead compared to cancelling and restarting the entire workflow.

=========

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.

During the physical installation and cabling of a Pure Storage FlashArray//XL, an Implementation Engineer must adhere to strict PCIe slot population rules to ensure optimal performance, proper cooling, and backend/frontend redundancy. The FlashArray//XL utilizes a different chassis layout than the standard //X or //C series, and the supported locations for Fibre Channel (FC) Host Bus Adapters (HBAs) are specific.

According to the FlashArray//XL Port Usage and Definitions hardware matrix, the 4-port 32G/64G Fibre Channel expansion cards are officially supported in PCIe slots 1, 5, and 8 . Other slots on the //XL chassis are strictly reserved for different functionalities. For instance, Slot 0, 4, and 6 are generally prioritized for NVMe/TCP, DirectFlash Shelf (DFS) connectivity, or hardware non-disruptive upgrade (HWNDU) cards. Installing a 4-port FC card in an unsupported slot (such as Slot 2, which requires special Product Management approval) will trigger hardware configuration alerts, prevent the array from passing its pre-installation hardware_check.py script, and potentially cause multipathing imbalances.

The output "Ping successful with CCM" is a specific success message returned by the puresupport test or purearray test connectivity checks. CCM stands for Cloud Connection Manager , which is the internal service or endpoint responsible for mediating the secure connection between the local FlashArray and the Pure1 cloud management platform.

When an Implementation Engineer sees this message, it confirms that the array can successfully resolve and reach the Pure1 infrastructure over the internet (specifically the pure1.purestorage.com or associated regional endpoints). This validates that:

DNS is functioning correctly (resolving the CCM hostname).

Firewall rules are permitting outbound HTTPS (port 443) traffic.

The array's management interface is routing correctly.

This connection is vital for "Phone Home" logs, Remote Assist sessions, and fleet management via the Pure1 mobile app or dashboard. It is distinct from the Fusion Fleet Coordinator (which manages fleet logic) and the cross-controller interconnect (which is internal hardware communication).

=========

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.

=========

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 performing a controller upgrade (Non-Disruptive Upgrade) from an //X50R3 to an //X50R4, the specific hardware configuration of the source array dictates the target bill of materials. The presence of SAS drives in the chassis indicates that the source is a legacy or transitional configuration, as the standard //X R4 platform is optimized for end-to-end NVMe (DirectFlash).

However, the question asks for the specific controller SKU required. In Pure Storage nomenclature for upgrades, the standard controller replacement part is typically the base model code, here FLASHARRAY//XC50 R4 .

The "XC" designation often refers to the controller component itself in upgrade kits. While special considerations apply to SAS media (which are usually phased out or require specific handling during R4 upgrades since R4 natively drops legacy SAS support on the motherboard), the controller part number itself remains the standard R4 SKU (Option C). Options like "SE" or "NS" (often denoting specific encryption or networking variants) are not the standard identifiers for the base controller upgrade in this context.

=========

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

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

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

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.

Following the successful completion of any major maintenance event—such as a Hardware Non-Disruptive Upgrade (HWNDU) or a Purity//FA software update—it is a critical best practice to force the array to immediately synchronize its state with the Pure1 cloud infrastructure. During the upgrade, the array may have been placed in maintenance mode (using the puremaintenance tag) to suppress alerts as controllers were rebooted or replaced.

Once the cluster is healthy and fully operational again, the Implementation Engineer must manually trigger the Callhome Connection Manager (CCM) to package and transmit the latest system telemetry, logs, and configuration state to Pure Storage Support. The correct and officially supported Purity CLI command to accomplish this is purearray phonehome --send-today .

Executing this command compiles the system logs, performance metrics, and hardware state generated throughout the current day (which encompasses the entire upgrade window) and pushes them over the secure outbound HTTPS tunnel to Pure Storage. This allows the backend support systems to baseline the new configuration, clear any lingering upgrade-related alerts, and ensure the array is accurately represented in the customer's Pure1 Manage dashboard. The other options presented (purelogs, --send-logs) use fabricated syntax that the Purity operating system will not recognize.

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.

=========

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.

=========

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

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

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

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

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

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

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