Using the Pure Storage PowerShellSDK2 - Part 4 - Classifying Workloads With FlashArray Tags
Welcome back to the fourth installment of our blog series on using the Pure Storage PowerShell SDK2. In this post, you’ll learn how to use Purity Tags to classify workloads, giving you the ability to search and manage resources in FlashArray and Cloud Block Store based on the types of workloads you’re running. Using the techniques in this post, combined with those learned in our last post, Using the Pure Storage PowerShellSDK2 - Part 3 - Getting Performance Data from FlashArray you can retrieve information about subsets of objects in your FlashArray or Cloud Block Store across several performance dimensions.
If you want to deep dive how into what a Tag is and how ot add, remove, and retrieve objects using Purity Tags, check out my post Working With Tags in FlashArray using PowerShell or the official documentation.
Using Tags to Add Application Context to Objects In Purity
When you apply Tags to an object, you add additional information to that object. You can add Tags to many objects in Purity, Volumes, Hosts, Host Groups, and Snapshots. Then, you can perform operations on those objects based on the Tags applied to them. In Purity, we can retrieve a set of objects based on the Tags, then take the set of objects and pass that into another PowerShell cmdlet or, more generally, into another call into an API Endpoint. In this post, we’ll focus on PowerShell.
That’s what we will do in this post: first, we’ll apply Tags to a collection of objects. We’ll then query our FlashArray to get a listing of objects that match a query; we will then take that listing of objects and pass that back into a PowerShell cmdlet to query the performance and space data associated with that subset of objects. Using this technique, we can start to analyze data in the array based on application context.
I’m a database professional, so we’ll use SQL Server as an example workload in this post. But you can use this technique to classify any workload, perhaps VMware ESXi Hosts, Host Groups, or Volumes for specific VMware clusters. We can go up stack a bit and classify workloads by application type: SAP, ERP, Financial systems, or even which environment like production, development, test, and more. You can tag many types of objects in Purity, Volumes, Hosts, Host Groups, and Snapshots. But in this post, the examples I will use are Volumes associated with SQL Server Instances. We will build a tagging scheme that will enable us to identify if a Volume is associated with a SQL Server and the name of the SQL Server with which Volume it is associated.
Now let’s dive into some examples; in this post, using this technique, you’ll be able to answer questions like:
- What’s the space accounting information for all Volumes associated with SQL Servers?
- What’s the data reduction information for all Volumes associated with SQL Servers?
- What are the hottest Volumes in terms of I/O for all of my SQL Servers?
Let’s get started.
Getting a List of Volumes Associated with our Workload
First, we’ll want to assign Tags to some Volumes in our FlashArray. The naming convention for Volumes in my array includes the server’s hostname in the volume name, so I can quickly build these two sets by searching for those strings in the Volume name. In the code below, I’m using Get-Pfa2Volume to build two sets of Volumes, one for a SQL Server named aen-sql-22-a and the other aen-sql-22-b. I’m also using the -Filter parameter to search all Volumes that match the string and then assign the output to a variable. We learned about filtering in the post Using the Pure Storage PowerShellSDK2 - Part 2 - Working With Data. We could certainly Tag each Volume one at a time, but what’s the fun? We can use this technique to handle this programmatically.
$VolumesSqlA = Get-Pfa2Volume -Array $FlashArray -Filter "name='*aen-sql-22-a*'" |
Select-Object Name -ExpandProperty Name
$VolumesSqlB = Get-Pfa2Volume -Array $FlashArray -Filter "name='*aen-sql-22-b*'" |
Select-Object Name -ExpandProperty Name
With those variables loaded with data, we can output them to verify they’re loaded appropriately. Here’s the contents of $VolumesSqlA
$VolumesSqlA
vvol-aen-sql-22-a-1-3d9acfdd-vg/Config-81e9c6b8
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-47094663
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-701193f8
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-620d202b
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-87ee3d7c
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-77084035
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-cabce242
vvol-aen-sql-22-a-1-3d9acfdd-vg/Swap-80dfb009
And here’s the contents of $VolumesSqlB.
$VolumesSqlB
vvol-aen-sql-22-b-9b9a3477-vg/Config-8419eb12
vvol-aen-sql-22-b-9b9a3477-vg/Data-91f04fdb
vvol-aen-sql-22-b-9b9a3477-vg/Data-c01d7ed3
vvol-aen-sql-22-b-9b9a3477-vg/Data-60a20eb7
vvol-aen-sql-22-b-9b9a3477-vg/Data-700eaca4
vvol-aen-sql-22-b-9b9a3477-vg/Data-d6a7747f
vvol-aen-sql-22-b-9b9a3477-vg/Data-f08e715f
vvol-aen-sql-22-b-9b9a3477-vg/Swap-8469cce4
So now we have two sets of Volumes; let’s move on and next apply Tags to those Volumes so that we can add application context to these Volumes.
Building a Tagging Structure for Application Context
Next up, we need to define our Tag structure. When using a Tag, we define a namespace, a key, and a value. A namespace is like a folder, a way to order a set of Tags. A tag is a key/value pair that can be attached to an object in Purity, such as a volume, host, host group, or snapshot. Tags enable you to attach additional metadata to objects for classification, sorting, and searching.
I’m defining a Tag structure in the code below; with this structure, I can tell if a Volume is associated with an SQL Server and which SQL Server Instance it’s associated with. First, let’s name the TagNamespace AnthonyNamespace because I’m creative like that. Second, the TagKey is SQLInstance. This tells me the tagged object is associated with a SQL Server instance. And then I defined two TagValues first, TagValueSqlA, which has a value of aen-sql-22-a, and TagValueSqlB, which has the value of aen-sql-22-b. This tells me this object is associated with a specific SQL Server instance in my environment. With this structure, I can assign these Tags to Volumes to quickly identify if a Volume is associated with SQL Server and which specific SQL Server instance is in my environment.
$TagNamespace = 'AnthonyNamespace'
$TagKey = 'SqlInstance'
$TagValueSqlA = 'aen-sql-22-a'
$TagValueSqlB = 'aen-sql-22-b'
Tagging Volumes
So now that we have our Tagging structure defined, let’s use that to assign Tags to the sets of Volumes we retrieved earlier which are stored in the variables $VolumesSqlA and $VolumesSqlB. In the code below, we use Set-Pfa2VolumeTagBatch to do just that. And let’s unpack this cmdlet and its parameters. First, the parameter -Array is an object with our FlashArray connection. -TagNamespace is the namespace we will store our Tags in; we’re using the variable $TagNamespace, which we initiated in the last section. Next, for -ResourceNames, we pass in a list of objects to which the Tags are applied. Here, we pass in the set of Volumes we populated earlier in the post, $VolumesSqlA. After that, -TagKey, passing in the variable $TagKey, which has a value of SqlInstance, tells us that this Volume is associated with a SQL Server Instance. Finally, -TagValue, passed in the variable $TagValueSqlA, represents a SQL Instance’s name; here, its value is aen-sql-22-a.
So let’s apply those Tags to all the Volumes associated with the SQL Server instance named aen-sql-22-a.
Set-Pfa2VolumeTagBatch -Array $FlashArray -TagNamespace $TagNamespace -ResourceNames $VolumesSqlA -TagKey $TagKey -TagValue $TagValueSqlA
Executing the cmdlet will immediately write the Tag output for all the resources tagged to the console. So here you see each of the Volumes tagged and the Key, Namespace, the Resource tagged, including both the Id and its Name , and finally the tag Value.
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='50b57085-75cd-7a0c-7ec4-a7d3f91ea22b'; Name='vvol-aen-sql-22-a-1-3d9acfdd-vg/Config-81e9c6b8'}
Value : aen-sql-22-a
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='152f99fc-1757-500a-e805-82750978d93e'; Name='vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-47094663'}
Value : aen-sql-22-a
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='4da7bcb9-15c9-a87f-acf1-c9fc9833733b'; Name='vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-701193f8'}
Value : aen-sql-22-a
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='cb5c9a63-ee11-c288-a2ba-e5f11ee88e0e'; Name='vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-620d202b'}
Value : aen-sql-22-a
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='50865654-638c-7a11-25c6-8c0d22f4c84d'; Name='vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-87ee3d7c'}
Value : aen-sql-22-a
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='3555d5c2-7dda-2722-e3de-bf7c0df067c3'; Name='vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-77084035'}
Value : aen-sql-22-a
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='48a94f98-b16c-aa20-1fd1-3d935bd04806'; Name='vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-cabce242'}
Value : aen-sql-22-a
Now, let’s go ahead and tag that second set of Volumes. Here’s the code to tag all Volumes associated with aen-sql-22-b.
Set-Pfa2VolumeTagBatch -Array $FlashArray -TagNamespace $TagNamespace -ResourceNames $VolumesSqlB -TagKey $TagKey -TagValue $TagValueSqlB
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='be9efb9f-538e-f00c-ce60-ddcd05ab9d68'; Name='vvol-aen-sql-22-a-1-3d9acfdd-vg/Swap-80dfb009'}
Value : aen-sql-22-a
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='d4b81c05-79b5-3bfa-ccf3-306364036d4e'; Name='vvol-aen-sql-22-b-9b9a3477-vg/Config-8419eb12'}
Value : aen-sql-22-b
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='6c527c17-6387-c5a9-b5f8-01c884e7fb1d'; Name='vvol-aen-sql-22-b-9b9a3477-vg/Data-91f04fdb'}
Value : aen-sql-22-b
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='4224be1b-34a3-f820-7340-bf68a745dde0'; Name='vvol-aen-sql-22-b-9b9a3477-vg/Data-c01d7ed3'}
Value : aen-sql-22-b
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='290f725d-f53d-969a-ab5a-bb6720cab6d2'; Name='vvol-aen-sql-22-b-9b9a3477-vg/Data-60a20eb7'}
Value : aen-sql-22-b
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='2a9e011d-bbb9-8244-7d78-ed336d3dbf95'; Name='vvol-aen-sql-22-b-9b9a3477-vg/Data-700eaca4'}
Value : aen-sql-22-b
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='fd3be0d2-1ddd-10c5-24ab-c235255c0835'; Name='vvol-aen-sql-22-b-9b9a3477-vg/Data-d6a7747f'}
Value : aen-sql-22-b
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='9b8381c8-75df-9a6f-63f0-d89737e5b23c'; Name='vvol-aen-sql-22-b-9b9a3477-vg/Data-f08e715f'}
Value : aen-sql-22-b
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='4c91be80-ad0e-bfe2-4db2-bc9a29ee7ae7'; Name='vvol-aen-sql-22-b-9b9a3477-vg/Swap-8469cce4'}
Value : aen-sql-22-b
Building a Set of Tagged Objects
We can use Tags to operate on a set of resources; in our case, that’s our sets of Volumes. Now, let’s list Volumes in our array based on a Tag. And in the code below, I’m using Get-Pfa2VolumeTag to do that. I’m getting all the Volumes with the Key value that matches the string SqlInstance. Based on our tagging scheme, this will give me all of the Volumes in our array associated with SQL Server instances. When we run the code below, $SqlVolumes will be populated with that list of Volumes.
$SqlVolumes = Get-Pfa2VolumeTag -Array $FlashArray -Namespaces $TagNamespace -Filter "Key='SqlInstance'"
Let’s take a second to revisit the structure of a tagged object. In the output below, we have one Volume’s tag output. Looking at the Resource property, you can find the Id and the Name of the resource. The Id is a unique identifier for this resource in the array. The Name is the string name for that object. When working with cmdlets and, more generally, the API, you’ll refer to objects by their Id. And you’ll see this in the upcoming example.
$SqlVolumes[0]
Copyable : True
Key : SqlInstance
Namespace : AnthonyNamespace
Resource : @{Id='50b57085-75cd-7a0c-7ec4-a7d3f91ea22b'; Name='vvol-aen-sql-22-a-1-3d9acfdd-vg/Config-81e9c6b8'}
Value : aen-sql-22-a
Getting Space Data for Sets of Tagged Volumes
Now, with $SqlVolumes populated with a listing of all Volumes associated with SQL Server Instances, we can pass that variable into many of our performance cmdlets to get data about those objects. We will first look at Get-Pfa2VolumeSpace. With this cmdlet, we can get the space data associated with Volumes stored in that variable. The cmdlet Get-Pfa2VolumeSpace’s parameter -Id takes a List<> of Id values. These are the Ids we introduced in the last section. You can access the Ids of every object in $SqlVolumes with the code $SqlVolumes.Resource.Id and pass that into the cmdlet Get-Pfa2VolumeSpace cmdlet, which will then process each object in the List<> and return data for each of objects. And that’s what we see below…the space accounting data for every Volume in our array associated with a SQL Server instance.
I’m formatting the output with Select-Object Name -ExpandProperty Space to get access to the space accounting data and then passing that into Format-Table to make this more human-readable.
Get-Pfa2VolumeSpace -Array $FlashArray -Id $SqlVolumes.Resource.Id |
Select-Object Name -ExpandProperty Space |
Format-Table
Name DataReduction Shared Snapshots System ThinProvisioning TotalPhysical TotalProvisioned TotalReduction Unique
---- ------------- ------ --------- ------ ---------------- ------------- ---------------- -------------- ------
vvol-aen-sql-22-b-9b9a3477-vg/Config-8419eb12 2.828 0 0.996 5354044 4294967296 797.372 5354044
vvol-aen-sql-22-b-9b9a3477-vg/Data-91f04fdb 16.476 0 0.860 596377613 107374182400 117.802 596377613
vvol-aen-sql-22-a-1-3d9acfdd-vg/Config-81e9c6b8 2.516 1793122 0.997 6357217 4294967296 934.452 4564095
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-47094663 14.648 2080325972 0.857 2814822262 107374182400 102.263 734496290
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-701193f8 5.073 1196464354 0.982 1552160502 107374182400 287.171 355696148
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-620d202b 6.281 33167388 0.999 52484597 107374182400 5117.587 19317209
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-87ee3d7c 40.597 925395 1.000 1752037 10995116277760 224583.469 826642
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-77084035 41.226 2229985 0.609 3751580 549755813888 105.487 1521595
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-cabce242 41.234 8839986 0.728 21529120 21990232555520 151.382 12689134
vvol-aen-sql-22-a-1-3d9acfdd-vg/Swap-80dfb009 1.000 0 1.000 0 17179869184 1.000 0
vvol-aen-sql-22-b-9b9a3477-vg/Data-c01d7ed3 4.966 0 0.980 404624133 107374182400 253.355 404624133
vvol-aen-sql-22-b-9b9a3477-vg/Data-60a20eb7 16.929 0 0.999 3082713 107374182400 22587.420 3082713
vvol-aen-sql-22-b-9b9a3477-vg/Data-700eaca4 40.995 0 1.000 306990 10995116277760 226788.391 306990
vvol-aen-sql-22-b-9b9a3477-vg/Data-d6a7747f 41.233 0 0.609 616516 549755813888 105.503 616516
vvol-aen-sql-22-b-9b9a3477-vg/Data-f08e715f 41.227 0 0.728 41216859 21990232555520 151.355 41216859
vvol-aen-sql-22-b-9b9a3477-vg/Swap-8469cce4 1.000 0 1.000 0 17179869184 1.000 0
The data returned isn’t ordered. So, we can combine this with the -Sort parameter to sort our data based on a property in the set returned. And here, we’re sorting on data reduction by using the property space.data_reduction. That’s pretty cool; now we have all the space accounting data for all Volumes associated with SQL Servers in our FlashArray. You can extend this to sort on any of the returned properties. Go ahead and try a few yourself.
Get-Pfa2VolumeSpace -Array $FlashArray -Id $SqlVolumes.Resource.Id -Sort "space.data_reduction" |
Select-Object Name -ExpandProperty Space |
Format-Table
Name DataReduction Shared Snapshots System ThinProvisioning TotalPhysical TotalProvisioned TotalReduction Unique
---- ------------- ------ --------- ------ ---------------- ------------- ---------------- -------------- ------
vvol-aen-sql-22-a-1-3d9acfdd-vg/Swap-80dfb009 1.000 0 1.000 0 17179869184 1.000 0
vvol-aen-sql-22-b-9b9a3477-vg/Swap-8469cce4 1.000 0 1.000 0 17179869184 1.000 0
vvol-aen-sql-22-b-9b9a3477-vg/Config-8419eb12 3.042 0 0.995 6665740 4294967296 641.722 6665740
vvol-aen-sql-22-a-1-3d9acfdd-vg/Config-81e9c6b8 3.176 5300081 0.995 11913574 4294967296 645.318 6613493
vvol-aen-sql-22-b-9b9a3477-vg/Data-c01d7ed3 5.108 0 0.977 465069227 107374182400 223.254 465069227
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-701193f8 5.332 2755136923 0.982 3105507690 107374182400 294.042 350370767
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-620d202b 5.471 84975893 0.998 118057678 107374182400 3091.225 33081785
vvol-aen-sql-22-b-9b9a3477-vg/Data-60a20eb7 13.163 0 0.999 4831997 107374182400 17578.674 4831997
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-47094663 16.239 5315324034 0.833 6118747901 107374182400 97.125 803423867
vvol-aen-sql-22-b-9b9a3477-vg/Data-91f04fdb 18.881 0 0.861 531651931 107374182400 136.096 531651931
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-87ee3d7c 50.756 1851823 1.000 2076568 10995116277760 280776.562 224745
vvol-aen-sql-22-b-9b9a3477-vg/Data-700eaca4 51.004 0 1.000 22785 10995116277760 282151.969 22785
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-cabce242 51.024 46445312 0.728 66313174 21990232555520 187.322 19867862
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-77084035 51.025 2170291 0.609 2816027 549755813888 130.558 645736
vvol-aen-sql-22-b-9b9a3477-vg/Data-d6a7747f 51.026 0 0.609 526543 549755813888 130.561 526543
vvol-aen-sql-22-b-9b9a3477-vg/Data-f08e715f 51.032 0 0.728 167306 21990232555520 187.352 167306
Getting Performance Data for Sets of Tagged Volumes
You can use this Tagging technique with many of the cmdlets available in the Pure Storage PowerShell SDK2 module. Let’s look at another cmdlet. Let’s get the performance data for all the Volumes associated with SQL Servers in our FlashArray with Get-Pfa2VolumePerformance. In the code below, we pass in the listing of our Volumes’ Ids with $SqlVolumes.Resource.Id into the parameter Ids, and the cmdlet returns the performance data for all those Volumes. Additionally, we’re using the -Sort parameter to sort the data by reads_per_sec descending. We then pipe that output to Select-Object, accessing the specific properties we’re interested in, and Format-Table to make the output more human-readable.
With this below code, I can quickly identify which SQL Server volume is performing the most read IO in my environment. We can extend this to any of the other performance dimensions available. I encourage you to test some others out; perhaps latency (UsecPerReadOp UsecPerWriteOp) is interesting to you, or IO Size (ReadBytesPerSec, WriteBytesPerSec).
Get-Pfa2VolumePerformance -Array $FlashArray -Id $SqlVolumes.Resource.Id -Sort "reads_per_sec-" |
Select-Object Name, BytesPerRead, BytesPerWrite, ReadBytesPerSec, ReadsPerSec, WriteBytesPerSec, WritesPerSec, UsecPerReadOp, UsecPerWriteOp |
Format-Table
Name BytesPerRead BytesPerWrite ReadBytesPerSec ReadsPerSec WriteBytesPerSec WritesPerSec UsecPerReadOp UsecPerWriteOp
---- ------------ ------------- --------------- ----------- ---------------- ------------ ------------- --------------
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-cabce242 524288 0 2808232064 5356 0 0 1426 0
vvol-aen-sql-22-b-9b9a3477-vg/Data-f08e715f 8192 0 2932341 358 0 0 1039 0
vvol-aen-sql-22-b-9b9a3477-vg/Config-8419eb12 0 2048 0 0 4095 2 0 289
vvol-aen-sql-22-b-9b9a3477-vg/Data-91f04fdb 0 0 0 0 0 0 0 0
vvol-aen-sql-22-a-1-3d9acfdd-vg/Config-81e9c6b8 0 1280 0 0 5119 4 0 227
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-47094663 0 0 0 0 0 0 0 0
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-701193f8 0 0 0 0 0 0 0 0
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-620d202b 0 0 0 0 0 0 0 0
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-87ee3d7c 0 0 0 0 0 0 0 0
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-77084035 0 0 0 0 0 0 0 0
vvol-aen-sql-22-a-1-3d9acfdd-vg/Swap-80dfb009 0 0 0 0 0 0 0 0
vvol-aen-sql-22-b-9b9a3477-vg/Data-c01d7ed3 0 4096 0 0 4095 1 0 293
vvol-aen-sql-22-b-9b9a3477-vg/Data-60a20eb7 0 30976 0 0 61944 2 0 351
vvol-aen-sql-22-b-9b9a3477-vg/Data-700eaca4 0 0 0 0 0 0 0 0
vvol-aen-sql-22-b-9b9a3477-vg/Data-d6a7747f 0 0 0 0 0 0 0 0
vvol-aen-sql-22-b-9b9a3477-vg/Swap-8469cce4 0 0 0 0 0 0 0 0
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-af7c2ace 0 0 0 0 0 0 0 0
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-e2e858fa 0 0 0 0 0 0 0 0
vvol-aen-sql-22-a-1-3d9acfdd-vg/Data-34318368 0 0 0 0 0 0 0 0
Wrapping Things Up and Key Take Aways
In this post, we looked at how to classify objects in your arrays using Tags. By demonstrating how to apply Tags to Volumes associated with SQL Server instances, this post provides a practical example of using the Pure Storage PowerShell SDK2 capabilities to classify workloads with Tags and gain insights into space accounting and performance metrics. Remember, you can apply Tags to many objects in your arrays, Hosts, Host Groups, Volumes, and Snapshots. You can also build a tagging structure that allows you to classify many workload types. With the ability to search and manage resources based on workload types, users can enhance their efficiency and streamline operations within FlashArray and Cloud Block Store environments.
Pure Storage PowerShell SDK2 Blog Series
This article is part of a blog series covering the Pure Storage PowerShell SDK2. Check out the other posts in this series:
- Using the Pure Storage PowerShellSDK2 - Part 1 - Connecting to FlashArray
- Using the Pure Storage PowerShellSDK2 - Part 2 - Working With Data
- Using the Pure Storage PowerShellSDK2 - Part 3 - Getting Performance Data from FlashArray
- Using the Pure Storage PowerShellSDK2 - Part 4 - Classifying Workloads With FlashArray Tags
- Using the Pure Storage PowerShellSDK2 - Part 5 - Checking Replication Status
You can find the supporting code for this blog series at this GitHub Repo and you can watch a webinar Unlocking the Full Potential of Pure Storage with APIs which has a walk-through of all of these demos.
