Difference between revisions of "How to setup ejfat nodes"
Jump to navigation
Jump to search
Line 19: | Line 19: | ||
##Edit the /etc/passwd file to include a line something like:<pre>myUserName:x:2101:1208:John Doe,,,:/daqfs/home/myUserName:/bin/bash</pre>where 2101 is user id and 1208 is epsci group. Hint: set your user id and group ids on the ejfat nodes to be the same as it is on the computer center machines or there will be an issue when you access files served by computer center like /daqfs/home or /group/... | ##Edit the /etc/passwd file to include a line something like:<pre>myUserName:x:2101:1208:John Doe,,,:/daqfs/home/myUserName:/bin/bash</pre>where 2101 is user id and 1208 is epsci group. Hint: set your user id and group ids on the ejfat nodes to be the same as it is on the computer center machines or there will be an issue when you access files served by computer center like /daqfs/home or /group/... | ||
# When sending UDP packets: | # When sending UDP packets: | ||
− | ** [https://notes.shichao.io/tcpv1/ch10/ UDP Fragmentation] | + | ** See '''[https://notes.shichao.io/tcpv1/ch10/ UDP Fragmentation]''' and '''[https://en.wikipedia.org/wiki/IP_fragmentation Wikipedia UDP Fragmentation]'''. The basic low-down is that UDP fragmentation should be avoided at all costs since it will slow things down, increase the amount of data sent, but most importantly in our case, fragmented packets will most likely be dropped. Look at the following section from the second link:<pre>In IPv4, hosts must make a best-effort attempt to reassemble fragmented IP packets with a total reassembled size of up to 576 bytes. They may also attempt to reassemble fragmented IP packets larger than 576 bytes, but they are also permitted to silently discard such larger packets. Applications are recommended to refrain from sending packets larger than 576 bytes unless they have prior knowledge that the remote host is capable of accepting or reassembling them.</pre><pre>In IPv6, hosts must make a best-effort attempt to reassemble fragmented packets with a total reassembled size of up to 1500 bytes, larger than IPv6's minimum MTU of 1280 bytes.[4] Fragmented packets with a total reassembled size larger than 1500 bytes may optionally be silently discarded. Applications relying upon IPv6 fragmentation to overcome a path MTU limitation must explicitly fragment the packet at the point of origin; however, they should not attempt to send fragmented packets with a total size larger than 1500 bytes unless they know in advance that the remote host is capable of reassembly. |
+ | </pre> | ||
+ | |||
** Unless you know your network can handle jumbo frames, break up your data into chunks of 1400 bytes. This is because you don't want to fragment your packets on high speed networks. On fast networks the 16-bit packet-id can overflow within the reassembly timeframe and - if the checksum matches or is not set - fragments of different packets could be reassembled. | ** Unless you know your network can handle jumbo frames, break up your data into chunks of 1400 bytes. This is because you don't want to fragment your packets on high speed networks. On fast networks the 16-bit packet-id can overflow within the reassembly timeframe and - if the checksum matches or is not set - fragments of different packets could be reassembled. | ||
</font> | </font> |
Revision as of 19:57, 15 December 2023
- Install BOOST with:
sudo apt-get install lib boost-all-dev
- Install ZMQ with:
sudo apt install libzmq3-dev
- For ERSAP install protobuf:
sudo apt install libprotobuf-dev protobuf-compiler
- For pip (python installer for python) install:
sudo apt install pip
- For prometheus:
- installation:
sudo apt install prometheus
sudo apt install prometheus-node-exporter
- python client libraries:
pip install prometheus-client
pip install prometheus-api-client
- exporter start up:
sudo systemctl start prometheus-node-exporter
sudo systemctl enable prometheus-node-exporter
- installation:
- For increased UDP buffer & queue sizes:
- For the long term write the following lines into the sysctl.conf file:
net.core.rmem_max=25000000
net.core.wmem_max=25000000
net.core.netdev_max_backlog=65536
- To make it immediately effective, execute:
sudo sysctl -w net.core.rmem_max=25000000
sudo sysctl -w net.core.wmem_max=25000000
sudo sysctl -w net.core.netdev_max_backlog=65536
ifconfig <ifname> txqueuelen 10000
- For the long term write the following lines into the sysctl.conf file:
- To mount /daqfs:
- sudo mkdir /daqfs
- edit /etc/fstab to include the line:
dubhe:/raid/daqfs nfs rw,bg 0 0
- sudo apt-get install nfs-common
- sudo mount /daqfs
- To change one's home directory to /daqfs/home/myUserName:
- Edit the /etc/passwd file to include a line something like:
myUserName:x:2101:1208:John Doe,,,:/daqfs/home/myUserName:/bin/bash
where 2101 is user id and 1208 is epsci group. Hint: set your user id and group ids on the ejfat nodes to be the same as it is on the computer center machines or there will be an issue when you access files served by computer center like /daqfs/home or /group/...
- Edit the /etc/passwd file to include a line something like:
- When sending UDP packets:
- See UDP Fragmentation and Wikipedia UDP Fragmentation. The basic low-down is that UDP fragmentation should be avoided at all costs since it will slow things down, increase the amount of data sent, but most importantly in our case, fragmented packets will most likely be dropped. Look at the following section from the second link:
In IPv4, hosts must make a best-effort attempt to reassemble fragmented IP packets with a total reassembled size of up to 576 bytes. They may also attempt to reassemble fragmented IP packets larger than 576 bytes, but they are also permitted to silently discard such larger packets. Applications are recommended to refrain from sending packets larger than 576 bytes unless they have prior knowledge that the remote host is capable of accepting or reassembling them.
In IPv6, hosts must make a best-effort attempt to reassemble fragmented packets with a total reassembled size of up to 1500 bytes, larger than IPv6's minimum MTU of 1280 bytes.[4] Fragmented packets with a total reassembled size larger than 1500 bytes may optionally be silently discarded. Applications relying upon IPv6 fragmentation to overcome a path MTU limitation must explicitly fragment the packet at the point of origin; however, they should not attempt to send fragmented packets with a total size larger than 1500 bytes unless they know in advance that the remote host is capable of reassembly.
- See UDP Fragmentation and Wikipedia UDP Fragmentation. The basic low-down is that UDP fragmentation should be avoided at all costs since it will slow things down, increase the amount of data sent, but most importantly in our case, fragmented packets will most likely be dropped. Look at the following section from the second link:
- Unless you know your network can handle jumbo frames, break up your data into chunks of 1400 bytes. This is because you don't want to fragment your packets on high speed networks. On fast networks the 16-bit packet-id can overflow within the reassembly timeframe and - if the checksum matches or is not set - fragments of different packets could be reassembled.