[Task] check coverage Azure VM types

[jnioche]

This page displays the Azure VM types and can be exported as a csv.
It would be good to compare its content to the instance types currently supported by the API.

[jnioche]

azure_vms.txt

[jnioche]

out of the 1274 entries in the file above, 998 are not found in the BoaviztAPI

azure_notfound.txt

[jnioche]

Count of missing entries by family code

342 D
217 E
87 F
57 M
35 S
31 B
30 NC
30 DC
29 L
29 FX
25 EC
15 DS
14 NV
10 G
9 ND
9 HB
9 A
6 H
4 NG
3 NP
2 HX
2 HC
1 NM
1 NCC

[jnioche]

The csv file in Boavizta contains duplicates entries for the following instance types

 3 f8s_v2
  3 f72s_v2
  3 f64s_v2
  3 f4s_v2
  3 f48s_v2
  3 f32s_v2
  3 f2s_v2
  3 f16s_v2
  2 standard_f8s_v2
  2 standard_f72s_v2
  2 standard_f64s_v2
  2 standard_f4s_v2
  2 standard_f48s_v2
  2 standard_f32s_v2
  2 standard_f2s_v2
  2 standard_f16s_v2
  2 m64s_v2
  2 m64s
  2 m64ms_v2
  2 m64ls
  2 m64ds_v2
  2 m64dms_v2
  2 m416s_v2
  2 m32ts
  2 m32ms_v2
  2 m32ls
  2 m32dms_v2
  2 m208s_v2
  2 m208ms_v2
  2 m128s_v2
  2 m128s
  2 m128ds_v2
  2 e96as_v4
  2 e8s_v4
  2 e8s_v3
  2 e8ds_v4
  2 e8as_v4
  2 e64s_v4
  2 e64s_v3
  2 e64ds_v4
  2 e64as_v4
  2 e4s_v4
  2 e4s_v3
  2 e4ds_v4
  2 e4as_v4
  2 e48s_v4
  2 e48s_v3
  2 e48ds_v4
  2 e48as_v4
  2 e32s_v4
  2 e32s_v3
  2 e32ds_v4
  2 e32as_v4
  2 e2s_v4
  2 e2s_v3
  2 e2ds_v4
  2 e2as_v4
  2 e20s_v4
  2 e20s_v3
  2 e20ds_v4
  2 e20as_v4
  2 e16s_v4
  2 e16s_v3
  2 e16ds_v4
  2 e16as_v4
  2 d96as_v4
  2 d8s_v4
  2 d8s_v3
  2 d8ds_v4
  2 d8as_v4
  2 d64s_v4
  2 d64s_v3
  2 d64ds_v4
  2 d64as_v4
  2 d4s_v4
  2 d4s_v3
  2 d4ds_v4
  2 d4as_v4
  2 d48s_v4
  2 d48s_v3
  2 d48ds_v4
  2 d48as_v4
  2 d32s_v4
  2 d32s_v3
  2 d32ds_v4
  2 d32as_v4
  2 d2s_v4
  2 d2s_v3
  2 d2ds_v4
  2 d2as_v4
  2 d16s_v4
  2 d16s_v3
  2 d16ds_v4
  2 d16as_v4

[jonperron]

Did you use a script @jnioche to find the duplicates ? Maybe we can add it in the CI, so we ensure future updates do not contain duplicated lines

[jnioche]

Did you use a script @jnioche to find the duplicates ? Maybe we can add it in the CI, so we ensure future updates do not contain duplicated lines

cat azure.csv | cut -f1 -d ',' | sort |uniq -c | sort -nr | grep -v '1 '
would be good to add something like that to the CI indeed

[jnioche]

the same instance type gets associated with different platforms. No idea which one gets picked, it does look right at all

grep f8s_v2 azure.csv

f8s_v2,8,16.0,64.0,0.0,0,Fsv2-Type4,"Vantage for instance specs (https://instances.vantage.sh/azure/), Azure docs for instance-host mapping, see README for details."
standard_f8s_v2,8,16.0,64.0,0.0,0,Fsv2-Type3,"Vantage for instance specs (https://instances.vantage.sh/azure/), Azure docs for instance-host mapping, see README for details."
f8s_v2,8,16.0,64.0,0.0,0,Fsv2-Type3,"Vantage for instance specs (https://instances.vantage.sh/azure/), Azure docs for instance-host mapping, see README for details."
standard_f8s_v2,8,16.0,64.0,0.0,0,Fsv2-Type2,"Vantage for instance specs (https://instances.vantage.sh/azure/), Azure docs for instance-host mapping, see README for details."
f8s_v2,8,16.0,64.0,0.0,0,Fsv2-Type2,"Vantage for instance specs (https://instances.vantage.sh/azure/), Azure docs for instance-host mapping, see README for details."

[jnioche]

I just asked my new best friend Claude about what happens when more than one mapping exists
@jonperron

  Why f8s_v2 returns results based on multiple server archetypes                                                                                                                                                                              
                                                                                                                                                                                                                                              
  The data: 3 duplicate entries in the CSV                                                                                                                                                                                                    
                                                                                                                                                                                                                                              
  In boaviztapi/data/archetypes/cloud/azure.csv, f8s_v2 appears three times, each pointing to a different host platform archetype:
                                                                                                                                                                                                                                              
  ┌──────┬────────┬─────────────────────────────┐
  │ Line │   id   │ platform (server archetype) │                                                                                                                                                                                             
  ├──────┼────────┼─────────────────────────────┤
  │ 372  │ f8s_v2 │ Fsv2-Type4                  │                                                                                                                                                                                             
  ├──────┼────────┼─────────────────────────────┤
  │ 388  │ f8s_v2 │ Fsv2-Type3                  │
  ├──────┼────────┼─────────────────────────────┤                                                                                                                                                                                             
  │ 404  │ f8s_v2 │ Fsv2-Type2                  │                                                                                                                                                                                             
  └──────┴────────┴─────────────────────────────┘                                                                                                                                                                                             
                                                                                                                                                                                                                                              
  Why there are 3 entries — intentional modeling of host uncertainty
                                                                                                                                                                                                                                              
  This reflects real-world Azure infrastructure: the f8s_v2 instance type can be deployed on three different physical host generations (Type2, Type3, Type4 of the Fsv2 server family). Azure doesn't expose which underlying host you're
  running on, so the data captures all known hardware mappings.                                                                                                                                                                               
                                                               
  You can verify this in boaviztapi/data/utils/complete_Azure_VMs/manual_instance_host_cleaned.csv:                                                                                                                                           
  f8s_v2,fsv2-type2,9,0,,                                                                                                                                                                                                                     
  f8s_v2,fsv2-type3,10,0,,
  f8s_v2,fsv2-type4,12,0,,                                                                                                                                                                                                                    
                          
  What the API actually returns — only the FIRST match                                                                                                                                                                                        
                                                      
  The critical code is in service/archetype.py:69-75:                                                                                                                                                                                         
                                                                                                                                                                                                                                              
  def get_archetype(archetype_name: str, csv_path: str) -> Union[dict, bool]:                                                                                                                                                                 
      with open(csv_path, encoding="utf-8") as csvfile:                                                                                                                                                                                       
          reader = csv.DictReader(csvfile)                                                                                                                                                                                                    
          for row in reader:              
              if row["id"].strip() == archetype_name.strip():                                                                                                                                                                                 
                  return row2json(row)  # ← returns on FIRST match, ignores the rest
      return False                                                                                                                                                                                                                            
                                                                                                                                                                                                                                              
  get_archetype returns on the first match and stops. So when you query f8s_v2, you always get the Fsv2-Type4 result (line 372, the first occurrence), and the Type3 and Type2 entries are silently ignored.                                  
                                                                                                                                                                                                                                              
  The consequence 
                                                                                                                                                                                                                                              
  The duplicate entries for Type2 and Type3 are dead data in practice — they exist in the CSV but are unreachable via the API. The f8s_v2 query is deterministic and always resolves to Fsv2-Type4. The min/max uncertainty propagated through
   the impact calculation reflects only that one hardware configuration, not the range across all three possible host types.                                                                                                                  
                                                                                                                            
  If the intent was to model uncertainty across host types, the current implementation doesn't support it — the archetype loader would need to aggregate across all matching rows rather than returning the first.    

so the question is: what do we do about it? do we keep the duplicate mappings and add some logic to get averages? might be a bit tricky
do we keep the duplicates and make it clear that only the first entry is returned? This does not add clarity at all
Do we remove the duplicates? we then loose some information and have to make an arbitrary choice

@da-ekchajzer @Shillaker any thoughts?

[Shillaker]

This is a problem with all cloud providers, where a specific VM type can be run on several different hypervisors, each with different specs. You as a user can't determine which type it will be; you are just guaranteed a VM with a given number of vCPUs and RAM running on one of them.

For example, in the docs it says:

The Fsv2-series sizes run on the Intel® Xeon® Platinum 8573C (Emerald Rapids), Intel® Xeon® Platinum 8370C (Ice Lake), Intel® Xeon® Platinum 8272CL (Cascade Lake) processors, or the Intel® Xeon® Platinum 8168 (Skylake) processors. Processor availability varies by region; sizes may run on any of the listed processors.

In addition to having different CPUs, these hypervisors will also have different RAM, storage, PSUs, etc. and therefore different environmental impact (manufacture and usage).

We basically have two options:

1. Pick one hypervisor type for each VM type
2. Use some kind of average of all hypervisor types for each VM type

I think we go with 1. because 2. adds a lot of complexity.

Which hypervisor we pick is up to us. We could go with the oldest and "worst" impact environmentally to be pessimistic or go with the latest generation, assuming that this is what you will get if you create a new VM today.