Create extent pools and balance them
When you create DS8000 extent pool pairs, you’re really deciding which server owns which capacity. A pool collects the extents of one or more ranks and belongs to one rank group, where group 0 is served by server0 and group 1 by server1. If you build the pools in pairs and fill them evenly, both servers share the work, and if you get it wrong one server ends up carrying everything.
Here you’ll create two pool pairs on the lab DS8A50, one for FlashCore Module ranks and one for FlashTier2 ranks. You’ll add the six ranks from Lesson 11 with chrank, read the results with lsextpool and showextpool, and pick up the rules that stop a rank from joining a pool.
You’ll start from your Lesson 11 ranks, so if you’ve reset the shell since then, run setup-11.txt first.
| Time | You need | By the end you can |
|---|---|---|
| 60 to 75 minutes | The practice shell, lab.profile and setup-11.txt from Lesson 11 | Create FB extent pool pairs in rank groups 0 and 1, assign ranks evenly with chrank, read pool capacity and status, and fix extent size and rank group mistakes |
What it is, in one line
An extent pool is a named container of rank extents that belongs to one rank group (server0 or server1); you build pools in pairs so volumes can be spread over both servers.
In Simple Words
Two kitchens in one big wedding hall
Think of a big wedding hall with two kitchens, left and right, each with its own cook, and a store at the back full of rice bags. The manager gives each kitchen its own shelves and stacks rice bags on them, but if he puts every bag in the left kitchen, the left cook works all day while the right one sits idle and the guests wait longer.
A sensible manager splits the bags evenly, half on the left shelves and half on the right, and he keeps biryani rice and plain rice on separate shelves so nobody mixes them up.
On a DS8000 the two cooks are server0 and server1, the shelves are extent pools, the rice bags are ranks and the two kinds of rice are the different drive types.
Engineer's View
Extent pools in detail
An extent pool is a logical container for extents from one or more ranks, with a name you choose and an ID the DS8000 gives it.
- Rank group:
-rankgrp 0pools are owned by server0 and-rankgrp 1pools by server1. Group 0 pools get even IDs (P0, P2, P4) and group 1 pools get odd IDs (P1, P3, P5), so you need at least two pools before both servers have something to do. - Storage type:
-stgtype fborckd, and a pool only holds ranks of the same type. - Extent size: whatever rank you add first sets the pool’s extent size, and every rank after it has to match.
- Encryption: with data-at-rest encryption on,
mkextpoolalso needs-keygrp. You have to decide on encryption before the first pool, because once pools exist it can’t be turned on or off. - Ranks in:
chrank -extpool Pn Rn, after which the rank shows the pool’s group.chrank -unassigntakes it out again (with Easy Tier it empties the rank first) and-reservestops new allocations on it. - Status:
lsextpoolshowsbelow,exceeded(past the warning threshold) orfull. You set-threshold,-limitand the over-provisioning cap-opratiolimitwithchextpool. - FlashCore Modules: pools built on FCM ranks only accept thin (ESE) volumes, and when the GUI offers a “Compressed” pool pair, it means FCM ranks.
IBM recommends creating pools in pairs per storage type or purpose, say one FB pair and one CKD pair, which is what the GUI’s Create Pool Pair does for you.
On DS8900F: the rules and commands are the same and only the drive types and capacities change.
How it works, step by step
Build your pools in this order. It’s the same for FB and CKD, apart from the storage type.
1Plan the pairs
Group the ranks by drive class and purpose, then split each group into two equal halves, one for rank group 0 and one for rank group 1. Six ranks of two classes gives you two pairs: four FCM ranks (two per side) and two FlashTier2 ranks (one per side).
2Create empty pools
mkextpool -rankgrp 0 -keygrp 1 -stgtype fb FCM_0 creates a pool and prints its ID. Give pools names that make the rank group obvious, for example ending in _0 and _1. A new pool shows status full with 0 GiB available because it has no ranks in it yet.
3Add ranks to the pools
chrank -extpool P0 R0 moves rank R0 into pool P0. Alternate as you go, one rank to the group 0 pool and the next to the group 1 pool, so the two sides stay equal, and you’ll see the rank’s Group column change to 0 or 1.
4Read the pool capacity
lsextpool shows each pool’s rank group, status, available GiB, % allocated and how many volumes it has. Adding -l gives you the logical, provisioned and physical capacity columns, and those matter on FlashCore Module pools because compression makes the logical space bigger than the physical space.
5Check the details of one pool
showextpool P0 shows the extent size, how many ranks and tiers the pool has, whether Easy Tier manages it, the threshold and limit settings and the encryption group. Run it to confirm a pool before you create volumes in it.
6Set thresholds and limits
chextpool -threshold sets the point where the pool status turns to exceeded, so your monitoring warns you well before the pool is full. -limit with -extentlimit enable caps how much of the pool can be used, and -opratiolimit caps over-provisioning on thin pools.
7Keep the pairs balanced over time
Each capacity upgrade should add ranks to both sides of a pair. Add three ranks to group 0 and none to group 1, and server0 ends up serving most of the new volumes. In a pool that Easy Tier manages, adding a rank also starts a redistribution of the existing extents onto it.
| Rule | What breaks if you ignore it |
|---|---|
| One rank group per pool | A pool is owned by one server only |
| At least one pool per rank group | The other server owns no capacity |
| Same extent size per pool | chrank refuses the rank |
| Same storage type per pool | FB and CKD ranks never mix |
| Encryption before first pool | Can’t change it later without rebuilding pools |
Hands-on lab: build two balanced extent pool pairs
Before you run any command, double-check it
Read every command twice before you press Enter. Check the target: the system or account, the IDs, the names and the sizes. These commands are for learning and were tested in our lab, not on your system. At work, run the read-only list commands first, follow your change process, make sure a backup exists, and ask a second person to check anything that changes or deletes data. You run them at your own risk.
You’ll build two pool pairs and fill them with the six ranks from Lesson 11, with FCM_0 and FCM_1 taking the FlashCore Module ranks and T2_0 and T2_1 taking the FlashTier2 ranks.
Practice shell note: the practice shell is our own teaching tool, not IBM software. Real DS CLI output looks very close to this but isn’t identical. The capacity numbers come from the shell’s formulas (including simulated FlashCore Module compression and a 64-extent reserve per rank), some messages are the shell’s own, and every output below is what the shell printed.
1Rebuild the ranks from Lesson 11
Run this:
python ds8sim.py -cfg lab.profile
simctl reset
quit
python ds8sim.py -cfg lab.profile -script setup-11.txt
python ds8sim.py -cfg lab.profile
lsrankYou should see this (after the script):
dscli> lsrank
Date/Time: 24 October 2026 11:22:16 UTC IBM DSCLI Version: 7.10.10.348 DS: IBM.2107-78SV001
ID Group State datastate Array RAIDtype extpoolID stgtype
==============================================================
R0 - Unassigned Normal A0 6 - fb
R1 - Unassigned Normal A1 6 - fb
R2 - Unassigned Normal A2 6 - fb
R3 - Unassigned Normal A3 6 - fb
R4 - Unassigned Normal A4 6 - fb
R5 - Unassigned Normal A5 6 - fb✅ Checkpoint: Six ranks R0 to R5 are Unassigned with no group.
2Create two pool pairs
Run this:
mkextpool -rankgrp 0 -keygrp 1 -stgtype fb FCM_0
mkextpool -rankgrp 1 -keygrp 1 -stgtype fb FCM_1
mkextpool -rankgrp 0 -keygrp 1 -stgtype fb T2_0
mkextpool -rankgrp 1 -keygrp 1 -stgtype fb T2_1
lsextpoolYou should see this:
dscli> mkextpool -rankgrp 0 -keygrp 1 -stgtype fb FCM_0
CMUC00000I mkextpool: Extent pool P0 successfully created.
dscli> mkextpool -rankgrp 1 -keygrp 1 -stgtype fb FCM_1
CMUC00000I mkextpool: Extent pool P1 successfully created.
dscli> mkextpool -rankgrp 0 -keygrp 1 -stgtype fb T2_0
CMUC00000I mkextpool: Extent pool P2 successfully created.
dscli> mkextpool -rankgrp 1 -keygrp 1 -stgtype fb T2_1
CMUC00000I mkextpool: Extent pool P3 successfully created.
dscli> lsextpool
Date/Time: 24 October 2026 11:22:16 UTC IBM DSCLI Version: 7.10.10.348 DS: IBM.2107-78SV001
Name ID stgtype rankgrp status availstor (2^30B) %allocated available reserved numvols
=======================================================================================
FCM_0 P0 fb 0 full 0 100 0 0 0
FCM_1 P1 fb 1 full 0 100 0 0 0
T2_0 P2 fb 0 full 0 100 0 0 0
T2_1 P3 fb 1 full 0 100 0 0 0Look at the IDs. The group 0 pools got P0 and P2 and the group 1 pools got P1 and P3, and every pool is full with 0 available since there are no ranks inside yet.
✅ Checkpoint: P0 and P2 are rank group 0, P1 and P3 rank group 1.
3Add the ranks evenly
R0 to R3 are the FlashCore Module ranks (from sites S1, S2, S5, S6), so two go into each FCM pool, while R4 and R5 are FlashTier2 and get one T2 pool each.
Run this:
chrank -extpool P0 R0
chrank -extpool P1 R1
chrank -extpool P0 R2
chrank -extpool P1 R3
chrank -extpool P2 R4
chrank -extpool P3 R5
lsrankYou should see this:
dscli> chrank -extpool P0 R0
CMUC00008I chrank: Rank R0 successfully modified.
dscli> chrank -extpool P1 R1
CMUC00008I chrank: Rank R1 successfully modified.
dscli> chrank -extpool P0 R2
CMUC00008I chrank: Rank R2 successfully modified.
dscli> chrank -extpool P1 R3
CMUC00008I chrank: Rank R3 successfully modified.
dscli> chrank -extpool P2 R4
CMUC00008I chrank: Rank R4 successfully modified.
dscli> chrank -extpool P3 R5
CMUC00008I chrank: Rank R5 successfully modified.
dscli> lsrank
Date/Time: 24 October 2026 11:22:16 UTC IBM DSCLI Version: 7.10.10.348 DS: IBM.2107-78SV001
ID Group State datastate Array RAIDtype extpoolID stgtype
==========================================================
R0 0 Normal Normal A0 6 P0 fb
R1 1 Normal Normal A1 6 P1 fb
R2 0 Normal Normal A2 6 P0 fb
R3 1 Normal Normal A3 6 P1 fb
R4 0 Normal Normal A4 6 P2 fb
R5 1 Normal Normal A5 6 P3 fbEach rank now shows a group and a pool. R0 and R2 (DA pair 0 and DA pair 2) both went to P0, which means each pool is also spread over both flash adapter pairs.
✅ Checkpoint: Three ranks in group 0 and three in group 1.
4Compare the pools
Run this:
lsextpoolYou should see this:
dscli> lsextpool
Date/Time: 24 October 2026 11:22:16 UTC IBM DSCLI Version: 7.10.10.348 DS: IBM.2107-78SV001
Name ID stgtype rankgrp status availstor (2^30B) %allocated available reserved numvols
=======================================================================================
FCM_0 P0 fb 0 below 199152 0 12745728 128 0
FCM_1 P1 fb 1 below 199152 0 12745728 128 0
T2_0 P2 fb 0 below 17701 0 1132901 64 0
T2_1 P3 fb 1 below 17701 0 1132901 64 0Both FCM pools are the same size and so are both T2 pools, so the pairs are balanced. The status has changed to below, the reserved column shows 64 extents held back per rank, and there are no volumes yet.
✅ Checkpoint: FCM_0 and FCM_1 show the same available GiB.
5Look inside one pool
Run this:
showextpool P0You should see this:
dscli> showextpool P0
Date/Time: 24 October 2026 11:22:16 UTC IBM DSCLI Version: 7.10.10.348 DS: IBM.2107-78SV001
Name FCM_0
ID P0
stgtype fb
totlstor (2^30B) 199154
availstor (2^30B) 199152
resvdstor (2^30B) 0
rankgrp 0
numranks 2
numvols 0
status below
%allocated 0
%available 100
configured 12745856
allowed 12745728
available 12745728
allocated 0
reserved 128
%limit 100
%threshold 85
virextstatus -
%virallocated -
%viravailable -
numtiers 1
etmanaged yes
extsize 16MiB
encryptgrp 1
(output shortened)P0 has two ranks, 16 MiB extents, one tier, Easy Tier management on and compression type compression, and that last one tells you it’s a FlashCore Module pool. As you saw in the Engineer’s View, that means only thin (ESE) volumes can go here.
✅ Checkpoint: You can point to numranks, extsize and compressiontype for P0.
6Save a setup script for the next lessons
Lessons 13 and 14 start from these pools, so save the file below as setup-12.txt. After a simctl reset, a single -script setup-12.txt run rebuilds the arrays, ranks and pools.
File setup-12.txt:
# setup-12.txt: arrays, ranks (Lesson 11) and extent pools (Lesson 12). Run after simctl reset.
mkarray -raidtype 6 -arsite S1
mkarray -raidtype 6 -arsite S2
mkarray -raidtype 6 -arsite S5
mkarray -raidtype 6 -arsite S6
mkarray -raidtype 6 -arsite S7
mkarray -raidtype 6 -arsite S8
mkrank -array A0 -keygrp 1 -stgtype fb
mkrank -array A1 -keygrp 1 -stgtype fb
mkrank -array A2 -keygrp 1 -stgtype fb
mkrank -array A3 -keygrp 1 -stgtype fb
mkrank -array A4 -keygrp 1 -stgtype fb
mkrank -array A5 -keygrp 1 -stgtype fb
mkextpool -rankgrp 0 -keygrp 1 -stgtype fb FCM_0
mkextpool -rankgrp 1 -keygrp 1 -stgtype fb FCM_1
mkextpool -rankgrp 0 -keygrp 1 -stgtype fb T2_0
mkextpool -rankgrp 1 -keygrp 1 -stgtype fb T2_1
chrank -extpool P0 R0
chrank -extpool P1 R1
chrank -extpool P0 R2
chrank -extpool P1 R3
chrank -extpool P2 R4
chrank -extpool P3 R5
lsextpool
✅ Checkpoint: setup-12.txt is saved in your lab folder.
Break It, Then Fix It
Here are two mistakes that either make pools lopsided or block a rank: a pool pair created in one rank group, and a rank with the wrong extent size.
1Break it: create both halves of a pair in rank group 0
A colleague copies the first command and changes only the name, so both “halves” land on server0.
Run this:
mkextpool -rankgrp 0 -keygrp 1 -stgtype fb VM_0
mkextpool -rankgrp 0 -keygrp 1 -stgtype fb VM_1
lsextpool -rankgrp 0You’ll get this:
dscli> mkextpool -rankgrp 0 -keygrp 1 -stgtype fb VM_0
CMUC00000I mkextpool: Extent pool P4 successfully created.
dscli> mkextpool -rankgrp 0 -keygrp 1 -stgtype fb VM_1
CMUC00000I mkextpool: Extent pool P6 successfully created.
dscli> lsextpool -rankgrp 0
Date/Time: 24 October 2026 11:22:16 UTC IBM DSCLI Version: 7.10.10.348 DS: IBM.2107-78SV001
Name ID stgtype rankgrp status availstor (2^30B) %allocated available reserved numvols
=======================================================================================
FCM_0 P0 fb 0 below 199152 0 12745728 128 0
T2_0 P2 fb 0 below 17701 0 1132901 64 0
VM_0 P4 fb 0 full 0 100 0 0 0
VM_1 P6 fb 0 full 0 100 0 0 0Why: there’s no error at all, and that’s what makes it dangerous. The clue is in the ID. VM_1 got P6, an even number, so it belongs to rank group 0 and every volume in “VM_1” would be served by server0.
Fix: delete the empty pool and create it again with -rankgrp 1, and this time it gets an odd ID.
Run this:
rmextpool -quiet P6
mkextpool -rankgrp 1 -keygrp 1 -stgtype fb VM_1
lsextpool P4 P5You should see this:
dscli> rmextpool -quiet P6
CMUC00003I rmextpool: Extent pool P6 successfully deleted.
dscli> mkextpool -rankgrp 1 -keygrp 1 -stgtype fb VM_1
CMUC00000I mkextpool: Extent pool P5 successfully created.
dscli> lsextpool P4 P5
Date/Time: 24 October 2026 11:22:16 UTC IBM DSCLI Version: 7.10.10.348 DS: IBM.2107-78SV001
Name ID stgtype rankgrp status availstor (2^30B) %allocated available reserved numvols
======================================================================================
VM_0 P4 fb 0 full 0 100 0 0 0
VM_1 P5 fb 1 full 0 100 0 0 0✅ Checkpoint: VM_0 is P4 (group 0) and VM_1 is P5 (group 1).
2Break it: add a 1 GiB rank to a 16 MiB pool
New capacity arrives, and someone builds the new rank with large extents and tries to add it to FCM_0.
Run this:
mkarray -raidtype 6 -arsite S3
mkrank -array A6 -keygrp 1 -stgtype fb -extsize 1GiB
chrank -extpool P0 R6You’ll get this error:
dscli> mkarray -raidtype 6 -arsite S3
CMUC00004I mkarray: Array A6 successfully created.
dscli> mkrank -array A6 -keygrp 1 -stgtype fb -extsize 1GiB
CMUC00007I mkrank: Rank R6 successfully created.
dscli> chrank -extpool P0 R6
CMUN02021E chrank: R6: The extent size of the rank (1GiB) does not match the extent size of extent pool P0 (16MiB).Why: P0’s extent size was fixed at 16 MiB by its first rank, and since a pool can only hold one extent size, the rank is refused. (The exact wording is a practice shell message.)
Fix: rebuild the rank with the default extent size. It’s empty and not in any pool, so rmrank is safe here.
Run this:
rmrank -quiet R6
mkrank -array A6 -keygrp 1 -stgtype fb
chrank -extpool P0 R6
lsrank -extpool P0You should see this:
dscli> rmrank -quiet R6
CMUC00010I rmrank: Rank R6 successfully deleted.
dscli> mkrank -array A6 -keygrp 1 -stgtype fb
CMUC00007I mkrank: Rank R6 successfully created.
dscli> chrank -extpool P0 R6
CMUC00008I chrank: Rank R6 successfully modified.
dscli> lsrank -extpool P0
Date/Time: 24 October 2026 11:22:16 UTC IBM DSCLI Version: 7.10.10.348 DS: IBM.2107-78SV001
ID Group State datastate Array RAIDtype extpoolID stgtype
==========================================================
R0 0 Normal Normal A0 6 P0 fb
R2 0 Normal Normal A2 6 P0 fb
R6 0 Normal Normal A6 6 P0 fb✅ Checkpoint: R6 is in P0 with R0 and R2. (Balance check: P0 now has three ranks and P1 two, so the next new rank should go to P1.)
This happened at work
Encryption came after the pools
This one comes from a pharmaceutical manufacturer that bought a DS8A50 for its lab results and batch records. Encryption was down in the project plan as a “phase 2” item, to be switched on once the key servers were ready, and meanwhile the storage team built four pool pairs, created 300 volumes and moved the first applications over.
Two months later a regulatory audit asked for proof that data at rest was encrypted. The team opened the GUI expecting to switch it on and found they couldn’t, because the system won’t change encryption once pools exist.
There was no shortcut, so they rebuilt. They borrowed capacity, migrated every volume to temporary pools on another system, deleted the pools and ranks, set up the encryption key group, rebuilt the ranks and pools with -keygrp and migrated everything back. That took six weekends of change windows and plenty of overtime, and although no data was lost, the audit finding stayed open for three months.
Their build checklist now has lskeygrp as step one, before the first mkrank or mkextpool, and security has to sign it off.
Common mistakes and troubleshooting
| Symptom | Likely cause | What to check / fix |
|---|---|---|
| One server much busier than the other | Pools or ranks mostly in one rank group | Check the Group column in lsextpool and lsrank, add ranks to the other side and migrate volumes |
| Pool of a “pair” has an even ID for the group 1 half | Created with -rankgrp 0 | Delete the empty pool and recreate it with -rankgrp 1 |
| chrank refuses a rank | Extent size or storage type differs from the pool | Check extsize in showextpool and rebuild the rank to match |
| mkextpool asks for -keygrp | Encryption is on | lskeygrp, then add -keygrp |
| Can’t enable encryption | Pools already exist | Decide encryption before the first pool |
| Standard volume refused in a pool | Pool built on FlashCore Modules | Use -sam ese (thin) in FCM pools |
| Pool status exceeded | Allocation above the threshold | Add ranks, free space, or adjust chextpool -threshold |
Get into the habit of running lsextpool after every capacity change and comparing the two halves of each pair. If they differ by more than one rank, note it in the change record.
Interview questions
Click a question to open it. They’re written the way an interviewer would ask them, and under each one you’ll find why they ask it and one way you could answer in your own words.
Fresher level
1. What is an extent pool and how does it relate to the two servers?
Why they ask this: They want to see that you understand pool ownership, since DS8000 balancing is built on it.
How you might answer: An extent pool is a container of extents from one or more ranks, and each pool belongs to one rank group, group 0 to server0 and group 1 to server1. That’s why we build pools in pairs, so the volumes can be spread over both servers.
2. How can you tell from a pool ID which server owns it?
Why they ask this: It’s a quick practical check, and interviewers like those.
How you might answer: Rank group 0 pools get even IDs like P0, P2, P4 and server0 owns them, while rank group 1 pools get odd IDs like P1, P3 and server1 owns those. You can also see it in the rankgrp column of lsextpool.
2–5 years experience
3. Walk me through building an FB pool pair for six ranks of two drive types.
Why they ask this: They’re looking for a clean, balanced procedure with checks along the way.
How you might answer: I’d make one pair per drive type, so two FCM pools and two FlashTier2 pools, created with mkextpool -rankgrp 0 or 1, -keygrp and -stgtype fb. Then I use chrank -extpool to put the FCM ranks in two per side and the FlashTier2 ranks one per side. Afterwards I check lsrank to see the groups are balanced and lsextpool to see each pair shows the same available capacity, and I’d mention that FCM pools only take ESE volumes.
4. chrank refuses to add a new rank to an existing pool. What do you check?
Why they ask this: It tests whether you can troubleshoot the pool rules.
How you might answer: I’d compare the rank with the pool, using showextpool for extsize and stgtype and lsrank -l for the rank. Most often it’s a different extent size, like a 1 GiB rank going into a 16 MiB pool, or an FB rank going into a CKD pool. If the rank is empty, I delete it and rebuild it with the matching extent size.
Senior level
5. Six months after go-live server0 runs at 80% and server1 at 30%. How do you investigate and fix it?
Why they ask this: A senior person has to spot imbalance and fix it without downtime.
How you might answer: First I’d look at lsextpool and lsrank for capacity per rank group, then lsfbvol by LSS to find where the busy volumes live, along with the performance data per server. Usually the growth all went into one pool, or the busy volumes sit only in even LSSs. To fix it I’d add ranks to the light side and move busy volumes across with volume migration, keeping the LSS and pool group aligned, and then add a balance check to the capacity process so it doesn’t creep back.
6. A security team wants encryption on an existing DS8000 with populated pools. What do you tell them?
Why they ask this: They want to know if you’re aware of the hard limits and can plan around them.
How you might answer: I’d tell them straight that data-at-rest encryption can’t be turned on once pools exist, so it means a rebuild. We’d migrate the data to temporary capacity, delete the pools and ranks, configure the key group, rebuild ranks and pools with -keygrp and migrate back. I’d size the change windows from the data volume, and I’d put encryption first on every build checklist from then on.
Quick quiz
Q1. Which server owns an extent pool created with -rankgrp 1?
- server0
- server1
- Both
- The HMC
Show answer
B: rank group 1 pools are owned by server1 and get odd IDs.
Q2. What sets the extent size of a pool?
- mkextpool -extsize
- The first rank added to it
- The volume type
- chextpool -extsize
Show answer
B: the first rank decides it, and later ranks have to match.
Q3. Which command adds a rank to a pool?
- mkextpool -rank
- chrank -extpool
- chextpool -add
- mkrank -pool
Show answer
B: chrank -extpool Pn Rn assigns the rank.
Q4. A new empty pool shows status full. Why?
- It is corrupt
- It has no ranks yet
- Encryption is off
- It is CKD
Show answer
B: with no ranks there are no extents, so 0 GiB is available.
Q5. Which volumes can you create in a FlashCore Module pool?
- Standard only
- ESE (thin) only
- TSE only
- Any type
Show answer
B: pools on FCM ranks only accept ESE volumes.
Quick recap
- Extent pools collect rank extents, and each belongs to rank group 0 (server0) or 1 (server1).
- Group 0 pools get even IDs and group 1 pools get odd ones.
- mkextpool -rankgrp 0|1 -keygrp ID -stgtype fb|ckd name; then chrank -extpool Pn Rn.
- A pool holds one storage type and one extent size, and its first rank sets the extent size.
- Build pools in pairs for each drive type and add ranks evenly to both sides.
- Decide on encryption before the first pool, and remember FCM pools only take ESE volumes.
Next lesson
Lesson 13: Create FB volumes (mkfbvol) → Next you’ll create thin and standard FB volumes in your new pools, with LSS planning and naming.
Further reading: create DS8000 extent pool
Want to go deeper into create DS8000 extent pool? IBM Redbook SG24-8559, section 10.3.4 walks through the full mkextpool and chrank example, and for the design reasons behind it, go back to Extent pools, rank groups and server affinity in the Architecture course.
You can also see the full plan for this course on the IBM DS8000 Implementation course page.
Try it yourself: open the DS8000 pool pair command builder, type a name and key group, and it writes both mkextpool commands for you, one per server.