Import from ESXi Extremely Slow

Let me know if there's anything else I can do to provide more useful information. I'm going to keep fiddling around and doing some testing next week (starting Tuesday, it's Canadian Thanksgiving) to see if I can make it do... something different.

Thanks again for all the effort you're putting into this.

I'm working on a different approach, hopefully I can have it done by tomorrow though. I created another branch in the Github page that says "direct-send", with this version it creates 8 SSH connections to the ESXi host and pulls the data down using dd. FUSE is used to have one path to pull from. In testing it's getting about 2x what HTTP does over 1GbE (again, haven't got 25GbE working)

https://github.com/PwrBank/pve-esxi-import-tools/tree/direct-send

I'm still working on getting the GUI part working though. But, in theory, this should completely bypass the HTTP limit. The caveat is the ESXi host will need SSH enabled, which I can imagine would be a fair trade off if it does actually increase performance.

I'll keep you informed, thanks for testing these out as well @spencerh!
 
  • Like
Reactions: Johannes S
@spencerh
Give the new release a try
https://github.com/PwrBank/pve-esxi-import-tools/tree/direct-send

You just need to setup SSH keys from the PVE to the ESXi hosts, it should automatically try to create 16 SSH connections and pull the VM down from the ESXi host using dd.

You can check the logs to see if it is using ssh+dd or falling back to HTTP mode

Bash:
journalctl -t esxi-folder-fuse --since "5 minutes ago" | grep -E "SSH connection|HTTP"

Let me know how that goes!
 
OK so I did a little bit of playing around with the 1.1.2 release this afternoon. Here's some questions and findings in no particular order:
  1. Does it fallback to HTTP whenever a password is provided? I don't seem to be able to figure out a way to get the GUI to let me add the ESX storage without providing a password. When I attach the storage through the UI I see the following process running, which implies to me that it's using a password:

    /usr/libexec/pve-esxi-import-tools/esxi-folder-fuse --skip-cert-verification --change-user nobody --change-group nogroup -o allow_other --ready-fd 10 --user root --password-file /etc/pve/priv/storage/MY-ESX.pw my-esx.example.com /run/pve/import/esxi/MY-ESX/manifest.json /run/pve/import/esxi/MY-ESX/mnt

    I assume from my testing results that it's still using SSH even when the password file is provided (assuming it can reach it over SSH) but I wanted to double-check since I wasn't 100% sure.

  2. I tried mounting the CLI directly but I'm a bit confused about the manifest.json. Based on the CLI that the GUI executes to mount the directory, it's pointing at the manifest.json on the mount. However, when I tried running:

    /usr/libexec/pve-esxi-import-tools/esxi-folder-fuse --skip-cert-verification --change-user nobody --change-group nogroup -o allow_other --user root my-esx.example.com /run/pve/import/esxi/MY-ESX/manifest.json /run/pve/import/esxi/MY-ESX/mnt

    it throws an error saying Error: failed to read manifest. That obviously makes some sense, since it can't read the manifest from a mount point that isn't mounted yet.

  3. I next tried mounting the storage through the UI to gain access to the manifest.json and then mounting the storage again to a second mount point:
    /usr/libexec/pve-esxi-import-tools/esxi-folder-fuse --skip-cert-verification --change-user nobody --change-group nogroup -o allow_other --user root my-esx.example.com /run/pve/import/esxi/MY-ESX/manifest.json /tmp/mnt

    This worked, but when I explored the datastores that were exposed through the new mountpoint they all appeared to be empty:

    Code:
    root@pve:~# ls /tmp/mnt/ha-datacenter/*
    /tmp/mnt/ha-datacenter/fs72_misc_vol:
    
    /tmp/mnt/ha-datacenter/fs72_test_datastore_01:
    
    /tmp/mnt/ha-datacenter/fs72_test_datastore_02:
    
    /tmp/mnt/ha-datacenter/fs72_test_datastore_03:

    This also appeared to be the case with the normally mounted storage, so maybe I'm just missing something about how this works:

    Code:
    root@hertz:~# ls /run/pve/import/esxi/MY-ESX/mnt/ha-datacenter/*
    /run/pve/import/esxi/MY-ESX/mnt/ha-datacenter/fs72_misc_vol:
    
    /run/pve/import/esxi/MY-ESX/mnt/ha-datacenter/fs72_test_datastore_01:
    
    /run/pve/import/esxi/MY-ESX/mnt/ha-datacenter/fs72_test_datastore_02:
    
    /run/pve/import/esxi/MY-ESX/mnt/ha-datacenter/fs72_test_datastore_03:

  4. Getting into my actual import tests, I'm still seeing basically exactly the same performance. I can see the SSH connections transferring data at ~20MB/s, but I never see more than 2-3 connections simultaneously:

    Screenshot 2025-10-14 at 4.48.33 PM.png

    When I run watch 'pgrep ssh | xargs ps -ww' I can see the dd processes being executed over SSH, but I never see more than one:

    ssh -o BatchMode=yes -o StrictHostKeyChecking=no root@my-esx.example.com dd if='/vmfs/volumes/fs72_test_datastore_03/TESTVM/TESTVM_1-flat.vmdk' bs=1048576 skip=19328 count=128 2>/dev/null
  5. I did a test using the SSH command to try to see what I could get going if I had nothing in between. I ran

    ssh -o BatchMode=yes -o StrictHostKeyChecking=no root@my-esx.example.com dd if='/vmfs/volumes/fs72_test_datastore_03/TESTVM/TESTVM_1-flat.vmdk' bs=1048576 | pv > /dev/null

    and was seeing speeds around 40MiB/s, but still far below my expected ~1000 MiB/s. I'm going to do some more experimentation on the ESX side tomorrow to see if maybe there's something misconfigured on that side that I'm missing that's causing the speeds to be slower than expected.

  6. I do see the expected messages in the logs:

    Code:
    root@pve:~# journalctl -t esxi-folder-fuse --since "30 minutes ago" -f | grep -E "SSH connection|HTTP"Oct 14 16:26:24 pve esxi-folder-fuse[29081]: SSH connection successful - using SSH streaming mode

  7. Just to make sure I'm not crazy, here's my iPerf3 test showing the connection running at ~10Gb/s:

    Proxmox (acting as client):
    Code:
    root@pve:~# iperf3 -c 192.168.0.123 -t 10 -i 5 -f g -p 8000
    Connecting to host 192.168.0.123, port 8000
    [  5] local 192.168.0.150 port 41206 connected to 192.168.0.123 port 8000
    [ ID] Interval           Transfer     Bitrate         Retr  Cwnd
    [  5]   0.00-5.00   sec  5.19 GBytes  8.91 Gbits/sec  1357   2.00 MBytes
    [  5]   5.00-10.00  sec  5.39 GBytes  9.25 Gbits/sec    0   2.00 MBytes
    - - - - - - - - - - - - - - - - - - - - - - - - -
    [ ID] Interval           Transfer     Bitrate         Retr
    [  5]   0.00-10.00  sec  10.6 GBytes  9.08 Gbits/sec  1357            sender
    [  5]   0.00-10.00  sec  10.6 GBytes  9.08 Gbits/sec                  receiver
    
    iperf Done.

    ESX (acting as server):
    Code:
    [root@my-esx:~] /usr/lib/vmware/vsan/bin/iperf3.copy -s -B 192.168.0.123 -p 8000
    -----------------------------------------------------------
    Server listening on 8000 (test #1)
    -----------------------------------------------------------
    Accepted connection from 192.168.0.150, port 41198
    [  5] local 192.168.0.123 port 8000 connected to 192.168.0.150 port 41206
    iperf3: getsockopt - Function not implemented
    [ ID] Interval           Transfer     Bitrate
    [  5]   0.00-1.00   sec   877 MBytes  7.35 Gbits/sec
    iperf3: getsockopt - Function not implemented
    [  5]   1.00-2.00   sec  1.09 GBytes  9.35 Gbits/sec
    iperf3: getsockopt - Function not implemented
    [  5]   2.00-3.00   sec  1.07 GBytes  9.24 Gbits/sec
    iperf3: getsockopt - Function not implemented
    [  5]   3.00-4.00   sec  1.09 GBytes  9.35 Gbits/sec
    iperf3: getsockopt - Function not implemented
    [  5]   4.00-5.00   sec  1.08 GBytes  9.25 Gbits/sec
    iperf3: getsockopt - Function not implemented
    [  5]   5.00-6.00   sec  1.07 GBytes  9.24 Gbits/sec
    iperf3: getsockopt - Function not implemented
    [  5]   6.00-7.00   sec  1.07 GBytes  9.24 Gbits/sec
    iperf3: getsockopt - Function not implemented
    [  5]   7.00-8.00   sec  1.08 GBytes  9.24 Gbits/sec
    iperf3: getsockopt - Function not implemented
    [  5]   8.00-9.00   sec  1.08 GBytes  9.30 Gbits/sec
    iperf3: getsockopt - Function not implemented
    [  5]   9.00-10.00  sec  1.07 GBytes  9.24 Gbits/sec
    iperf3: getsockopt - Function not implemented
    [  5]  10.00-10.00  sec  4.12 MBytes  8.85 Gbits/sec
    - - - - - - - - - - - - - - - - - - - - - - - - -
    [ ID] Interval           Transfer     Bitrate
    [  5]   0.00-10.00  sec  10.6 GBytes  9.08 Gbits/sec                  receiver
    -----------------------------------------------------------
    Server listening on 8000 (test #2)
    -----------------------------------------------------------

Based on this testing and comparing it with your test results, I'm increasingly inclined towards thinking that there's something with my ESX server in particular that's slowing down this transfer, rather than the bottleneck being something to do with the importer itself. I'm going to see if I can find anything tomorrow (and I did see a few promising Google results before the end of my day) that will let me improve the SSH performance coming out of ESX.
 
  • Like
Reactions: waltar
Awesome feedback @spencerh !

I think I found the issue you are seeing with the sessions. It was waiting on the qemu import process to finish before opening another SSH thread. So to get around that I implemented 16 stay-alive SSH connections that get round-robin'd to balance the load. It now pre-fetches about 8-10 blocks ahead of the qemu request to keep the buffers full.


Here's the 16 active sessions
1760534008302.png

But I was running into 4 cores being absolutely pegged by the fuse. Changed the binary to allow up to 16 threads.
1760534031426.png

So now it looks like this
1760534074240.png

However, I need to think on this a little bit. I'm maxing it out at ~40MiB/s using this technique, which IDK if that's because of the SSH encryption bottlenecking the threads or if there's something else going on.

There has got to be a way to get the data off the ESXi host without hitting such low bottlenecks like this. I did an A-B comparision with this exact binary:

Default 1.0.1 binary:
  • Time: 6 minutes 34 seconds (394 seconds)
  • Speed: 76-88 MiB/s average
  • CPU: 1% (very low)
  • Memory: 365 MB
  • Mode: HTTP/2 only (no SSH capability)
  • Result: ✅ Completed successfully

Current 1.1.3 binary in the Gitrepo source:
  • Time: DNF (Did Not Finish) - crashed at 4%
  • Speed: Started 45-48 MiB/s, dropped to 32 MiB/s, then stalled
  • CPU: 40% (much higher than factory's 1%)
  • Memory: 1.9 GB (5x more than factory's 365 MB)
  • Mode: SSH with persistent connections + prefetching
  • Result: ❌ Crashed at 1.2 GiB / 30 GiB
The crash is probably due to OOM when the buffer fills up, but that's fixable. The main thing is to figure out why there's only 45MB/s being pulled across 16 threads... Maybe I could change the SSH encryption type to something less expensive?

If any one has any ideas, let me know. Cause at the moment SSH looks like it'll be too resource expensive to actually do.
 
  • Like
Reactions: waltar
Actually... Here's a thought. @spencerh

Can you run a raw bandwidth test using netcat and dd to your Proxmox? You'll have to disable the firewall on the ESXi host temporarly, unless you specifically add the port you are wanting to use to the firewall rules.

On the Proxmox side:
Bash:
nc -l -p 4444 | dd bs=16M of=test0vm-flat.vmdk

And after running that, run this on the ESXi side:
Bash:
dd if=/vmfs/volumes/local/test0vm/test0vm-flat.vmdk bs=16M | nc IPADDRESSofPROXMOX 4444

You wont see any output on the console but you should see the bandwidth on both sides spike

This can be improved with compression and multithreading, but lets just see how it performs with just one transfer. Doing this I'm able to completely max out a 1GbE connection with less than 1% CPU usage. Obviously it's un-encrypted, but whatever.

32212254720 bytes (32 GB, 30 GiB) copied, 279.519 s, 115 MB/s

That should give us a good indicator of what's going on. It should be faster than the import no matter what, since you're not processing the incoming blocks at all, just pushing and pulling from one side to the other. Then we can see if it's the storage bottlenecking or something else.

In theory I could swap out the ssh implementation and put in netcat. Then it's just a straight raw data transfer over a TCP port.
 
Last edited:
  • Like
Reactions: waltar
I was also doing a bit of research this morning, and it looks like the throughput limitations of SSH from ESX and it seems that this is potentially an issue with resource limits applied to the busybox environment on the ESX side. Nothing conclusive, but here are some of the references to this issue I found:

https://community.broadcom.com/vmwa...emove-performance-caps-from-scp-on-esxi-hosts
https://33hops.com/vmware-esxi-ssh-scp-throughput-limitations.html
https://www.reddit.com/r/vmware/comments/90ys32/esx_limiting_scp_copy_speed/
https://elatov.github.io/2012/04/why-scp-and-dd-from-an-esxi-host-are-not-good-performance-tools/
https://serverfault.com/questions/380778/vmware-seems-to-throttle-scp-copies-what-can-be-the-reason

I'll give the new version of the importer a shot and try the raw throughput tests and let you know how that goes.

EDIT: Something else I'm wondering is if it would be possible to get the same ESX importer dialogue to show for storage types other than ESX. If, for example, I add NFS as a storage volume with the Import storage type selected, I can see the VMDK files but I can't initiate the importer from the VMX file in the same way as with the ESXi storage type. A feasible way to handle this would be to setup a shared NFS server and move the VMs onto that, but it seems you lose functionality when importing in this way.
 
Last edited:
I was also doing a bit of research this morning, and it looks like the throughput limitations of SSH from ESX and it seems that this is potentially an issue with resource limits applied to the busybox environment on the ESX side. Nothing conclusive, but here are some of the references to this issue I found:

https://community.broadcom.com/vmwa...emove-performance-caps-from-scp-on-esxi-hosts
https://33hops.com/vmware-esxi-ssh-scp-throughput-limitations.html
https://www.reddit.com/r/vmware/comments/90ys32/esx_limiting_scp_copy_speed/
https://elatov.github.io/2012/04/why-scp-and-dd-from-an-esxi-host-are-not-good-performance-tools/
https://serverfault.com/questions/380778/vmware-seems-to-throttle-scp-copies-what-can-be-the-reason

I'll give the new version of the importer a shot and try the raw throughput tests and let you know how that goes.

I wonder if this is relevant as well.
https://www.reddit.com/r/vmware/comments/90ys32/comment/e2ubw41/
 
OK just finished the nc test. It doubled throughput but it seems to still be a long shot from the theoretical network throughput we'd expect:


Code:
root@pve:~# nc -l -p 8000 -s 192.168.0.150 | pv | dd bs=16M of=/rpool/data/testfile.vmdk
50.0GiB 0:09:19 [91.6MiB/s] [                                                 <=>                            ]
0+5777633 records in
0+5777633 records out
53687091200 bytes (54 GB, 50 GiB) copied, 559.008 s, 96.0 MB/s

The transfer peaked at ~250MiB but it didn't sustain that for long.
 
  • Like
Reactions: waltar
Is the 192.168.0.150 interface on the 10GbE? Stupid question, but just making sure. Though, it should still be hitting 112MB/s to max out even a 1GbE connection.

I just got done doing some tests, all over a 1GbE connection. Big post incoming.

Straight Netcat
PVE side:

nc -l -p 4444 | dd bs=16M of=test0vm-flat.vmdk


ESXi side:
dd if=/vmfs/volumes/local/test0vm/test0vm-flat.vmdk bs=16M | nc 10.10.5.69 4444

Result:
0+3076902 records in
0+3076902 records out
32212254720 bytes (32 GB, 30 GiB) copied, 279.519 s, 115 MB/s

With bzip2 compression
DNF, way too slow, limited to 1 thread during compression on the ESXi

PVE side:
nc -l 4444 | bzip2 -d | dd bs=16M of=test0vm-flat.vmdk


ESXi side:
dd if=/vmfs/volumes/local/test0vm/test0vm-flat.vmdk bs=16M | bzip2 -c | nc 10.10.5.69 4444

Result:
0+1451367 records in
0+1451367 records out
7483518976 bytes (7.5 GB, 7.0 GiB) copied, 874.375 s, 8.6 MB/s

With gzip compression
DNF, way too slow, limited to 1 thread during compression on the ESXi

PVE side:
nc -l -p 4444 | gzip -d | dd bs=16M of=test0vm-flat.vmdk

ESXi side:
dd if=/vmfs/volumes/local/test0vm/test0vm-flat.vmdk bs=16M | gzip -c | nc 10.10.5.69 4444

Result:
gzip: stdin: unexpected end of file
0+124275 records in
0+124275 records out
4078734677 bytes (4.1 GB, 3.8 GiB) copied, 410.276 s, 9.9 MB/s

With lzop compression
Slower, but it did compress all the blank space, so while it did finish faster, it didn't maintain a maxed out connection due to the CPU limit on the ESXi host

PVE side:
nc -l -p 4444 | lzop -d | dd bs=16M of=test0vm-flat.vmdk

ESXi side:
dd if=/vmfs/volumes/local/test0vm/test0vm-flat.vmdk bs=16M | lzop -c | nc 10.10.5.69 4444

Result:
0+491520 records in
0+491520 records out
32212254720 bytes (32 GB, 30 GiB) copied, 204.742 s, 157 MB/s

With pigz compression
Might be better on more powerful machine, the ESXi host I am using is a 6 core 8th gen i5... But it does 100% max out the cores on the ESXi host

PVE side:
nc -l -p 4444 | pigz -d | dd bs=16M of=test0vm-flat.vmdk

ESXi side:
dd if=/vmfs/volumes/local/test0vm/test0vm-flat.vmdk bs=16M | pigz -c | nc 10.10.5.69 4444

Result:
0+859444 records in
0+859444 records out
32212254720 bytes (32 GB, 30 GiB) copied, 151.506 s, 213 MB/s

Results
The slight speed loss using pigz makes up for it actually compressing the empty space which would speed up a lot of imports that had sparce space. Though it might actually be perfectly fine on normal server hardware, my test ESXi is just a crummy old Lenovo M720q with 8GB of RAM.
1760539933310.png



@spencerh Based on your results I'd verify your storage is working correctly. You may want to (be very careful) some dd commands on the ESXi host to verify disk read speeds. Sounds like it can't pull enough data off to saturate the NIC.
 
  • Like
Reactions: waltar
Yeah, the 192.168.0.150 interface is the PVE side of the iPerf3 test I posted earlier.

So interestingly it seems like I'm only able to pull ~0.9 Gb/s running dd and sending the results to null.

Code:
[root@my-esx:~] time dd if=/vmfs/volumes/fs72_test_datastore_03/TESTVM01/TESTVM01_1-flat.vmdk bs=16M of=/dev/null
3200+0 records in
3200+0 records out
real    7m 53.35s
user    1m 26.23s
sys    0m 0.00s

Going to try again with a smaller block size and see if that affects anything.

EDIT: Switching to a block size of 4M reduced the time to 6m 33s resulting in an effective speed of ~1.1 Gb/s. I think you're onto something here vis a vis the storage being the bottleneck.
 
Last edited:
  • Like
Reactions: waltar
Local dd "effective speed of ~1.1 Gb/s." - it's Gbit (dd wouldn't give Gbit) or GByte ? That's the speed of 1 hdd or 1 slow nvme and assumed small for a esxi server with a couple of vm's.
 
What happens if you dd null or random over to the PVE host /dev/null? See if it maxes out the NIC. Then we can at least eliminate it's an issue with transfer method and more an issue with storage.

I'm thinking at the moment on how netcat could be implemented. There's a few issues that may or not be a problem. Right now the import process is creating a "local" filesytem with FUSE and it seems to be sequentially reading the data off the FUSE mount to do the import. However, if we were to do something like netcat and dd we could only retrieve data sequentially...

Trying to think how it can be streamed and injected at the same time, instead of using a local storage spot to put it temporarily. Which would be impossible to deal with on larger VMs. And there's no good way to resume an import etc etc...

Would it be smart to use the FUSE filesystem as is to let Proxmox know what's available to be imported and then as it requested the chunks, just feed it the data from the dd pipe?

Edit:
Something like this?
  • Detect when Proxmox calls qemu-img convert
  • Instead of reading from FUSE mount, spawn netcat transfer
  • Feed the netcat stream directly to qemu-img convert stdin
 
Last edited:
Local dd "effective speed of ~1.1 Gb/s." - it's Gbit (dd wouldn't give Gbit) or GByte ? That's the speed of 1 hdd or 1 slow nvme and assumed small for a esxi server with a couple of vm's.

It's gigabit. I just did the math myself, dd just outputs total chunks and total time. The disk in question was 50 GiB and the dd process took 7 minutes and 53 seconds which gives an effective speed of around 0.85 Gb/s if my/Wolfram Alpha's math is right.

What happens if you dd null or random over to the PVE host /dev/null? See if it maxes out the NIC. Then we can at least eliminate it's an issue with transfer method and more an issue with storage.

I'm thinking at the moment on how netcat could be implemented. There's a few issues that may or not be a problem. Right now the import process is creating a "local" filesytem with FUSE and it seems to be sequentially reading the data off the FUSE mount to do the import. However, if we were to do something like netcat and dd we could only retrieve data sequentially...

Trying to think how it can be streamed and injected at the same time, instead of using a local storage spot to put it temporarily. Which would be impossible to deal with on larger VMs. And there's no good way to resume an import etc etc...

Would it be smart to use the FUSE filesystem as is to let Proxmox know what's available to be imported and then as it requested the chunks, just feed it the data from the dd pipe?

Edit:
Something like this?
  • Detect when Proxmox calls qemu-img convert
  • Instead of reading from FUSE mount, spawn netcat transfer
  • Feed the netcat stream directly to qemu-img convert stdin

I dd-ed over 10 GiB of zeroes and got a basically sustained rate of ~250MiB/s

Code:
[root@my-esx:~] dd if=/dev/zero bs=16M count=640 | nc 192.168.0.150 8000
640+0 records in
640+0 records out

Code:
root@pve:~# nc -l -p 8000 -s 192.168.0.150 | pv | dd bs=16M of=/dev/null
10.0GiB 0:00:38 [ 264MiB/s] [                                                        <=>                     ]
0+1353822 records in
0+1353822 records out
10737418240 bytes (11 GB, 10 GiB) copied, 38.6578 s, 278 MB/s

I think that is additional evidence that I may be getting bottlenecked on my storage. I'm reading the VMDKs off of a SAN attached by fibre channel, so I don't think I'm maxing out per-disk throughput, but I could be wrong on that front.

In terms of using nc as part of the importer process, I was thinking of doing something similar by hand if I can't get this working. Basically, just instantiate the VM configs and then pull the disks over manually, in one way or another.

The more I think about it, the more I'm convinced that long term the best solution would be to be able to use the ESXi importer tool without having to define the ESXi storage in Proxmox. If, for example, I could mount an NFS share or something that has my VMs stored on it and attach that to Proxmox, then be able to point the Import option at the .VMX instead of the .VMDK (which is, as far as I can tell, only an option when you're looking at the ESXi storage type. When I copied over the VM into local storage and defined it as an Import storage, it only showed me the VMDKs, not the VMX-es. If Proxmox were to support creating VMs from .VMX files on any type of storage tagged as holding the Import type, it would give more flexibility in terms of the backhaul protocol without needing to do a whole bunch of trickery to get the data out of ESX directly.

That being said, I do think that currently the idea of using nc as the data backend and just having the FUSE mount expose the available VMs is a smart approach.
 
The more I think about it, the more I'm convinced that long term the best solution would be to be able to use the ESXi importer tool without having to define the ESXi storage in Proxmox. If, for example, I could mount an NFS share or something that has my VMs stored on it and attach that to Proxmox, then be able to point the Import option at the .VMX instead of the .VMDK (which is, as far as I can tell, only an option when you're looking at the ESXi storage type. When I copied over the VM into local storage and defined it as an Import storage, it only showed me the VMDKs, not the VMX-es. If Proxmox were to support creating VMs from .VMX files on any type of storage tagged as holding the Import type, it would give more flexibility in terms of the backhaul protocol without needing to do a whole bunch of trickery to get the data out of ESX directly.

That being said, I do think that currently the idea of using nc as the data backend and just having the FUSE mount expose the available VMs is a smart approach.

I was actually doing testing using this method initially. You can mount a VMFS path directly on the storage in Proxmox using vmfs6-tools. You can then run the qemu-import tool.
 
I was actually doing testing using this method initially. You can mount a VMFS path directly on the storage in Proxmox using vmfs6-tools. You can then run the qemu-import tool.

I'm going to investigate how difficult this is, as since we've repurposed some of our ESX hosts into our Proxmox test environment we're already wired up to a few of the datastores off the SAN. I was just really trying to avoid straying from the beaten path, but I think we left that idea in the rearview after the third round of modifications to the importer ;)
 
Lol, very true. We're almost done converting to Proxmox from ESXi but we do have a huge DC to convert left on the list and with the current import tools it'll take way too long. So either going to go the vmfs6 route or hopefully get the import tool to work and make it usable for others.
 
That's much of the same issue we're having. 20 min for a 50GiB VM isn't the end of the world, but for some of our larger VMs there's no way we can sustain the downtime to move 2TiB at that rate.

I know I've said this already, but I am deeply appreciative of the work you've put into improving this tool.
 
Appreciate it!

We have a few 10TB+ VMs to move and they wouldn't be done within a week of starting them lol

I learned on the last large cutover that the current tool slows down over time after the first few TB. It went from roughly 30 mins for 60GB to about 60 mins for 60GB. I was praying it would be done before Monday morning and luckily it finished 10PM on Sunday. :oops:

I'll keep cracking away at it and see if I can come up with something realistic. I really need to just setup another 25GbE host so I don't have to bum others to test lol.
 
So, interesting finding. Trying to get the import process to process a stream of data vs chunks, so tried using qemu-img dd in doing so it goes from absolutely transferring as fast as possible to about 75-78MB/s. So there seems to be processing bottleneck with qemu-img. Checking the processes, it's not even maxing out the cores it's using - So it's probably something with the processing itself that takes a while.




MethodTimeSpeedOverhead
Plain dd + netcat4m 54s109.5 MB/sNone
Compressed raw + qemu-img dd6m 52s78.2 MB/s+28.6% slower
Uncompressed raw + qemu-img dd7m 7s75.3 MB/s+31.2% slower
Compressed qcow2 + qemu-img dd7m 11s74.6 MB/s+31.9% slower
HTTP (reference)-76-88 MB/s-


Edit:

Yeah, definitely a qemu thing.

Bash:
/usr/bin/time -v qemu-img dd -f raw -O raw osize=32212254720 if=/root/test-netcat-plaindd.raw of=/root/test-local-qemu-dd.raw

That took almost 7 minutes, so the 75MB/s thing.

But if you did qemu-img convert it does it in 9 seconds, or 3GB/s.


Code:
qemu-img convert -f raw -O raw /root/test-netcat-plaindd.raw /root/test-local-qemu-convert.raw

Yeesh.
 
Last edited:
  • Like
Reactions: spencerh