This document discusses ways to provide quality of service (QoS) without using traditional QoS mechanisms for modern storage systems like Ceph. It describes using techniques like limiting client I/O, traffic shaping at gateways, adjusting iSCSI queue depths, and using Linux traffic control (tc) tools to provide bandwidth caps or inject latency. While upstream Ceph efforts work on native QoS, these techniques can provide some control over performance for different clients in the interim. The document cautions that solutions like tc are complex to configure for many clients and may drop packets.
Build reliable, traceable, distributed systems with ZeroMQRobin Xiao
ZeroMQ is used to build a distributed system with reliable and traceable communication. It allows exposing code over RPC with minimal modification. Exceptions are properly propagated across services. The system is language agnostic and brokerless. Introspection allows viewing methods and signatures without opening code. Streaming APIs allow continuous updates without timeouts. Tracing helps profile nested calls and identify performance bottlenecks. Security is not implemented but could use SSL or authentication layers.
This document describes Xavier Mertens' approach to implementing a full packet capture (FPC) infrastructure using Docker containers and Moloch. Key components include Moloch capture sensors running in Docker containers to perform packet capture and transfer files to a central Moloch server, and a Moloch server container that indexes transferred PCAP files for analysis. This distributed approach allows capturing traffic from multiple locations and centralizing it for long-term retention and investigation in Moloch. The open source project is available on GitHub to allow others to test and deploy the FPC solution.
Service Discovery using etcd, Consul and KubernetesSreenivas Makam
Overview of Service Discovery and Service Discovery using etcd, Consul, Kubernetes and Docker. Presented at Open source meetup, Bangalore(http://www.meetup.com/Bangalore-Open-Source-Meetup/events/229763724/)
ngrep is a network packet sniffer that allows filtering and matching regular expressions against TCP/IP and other protocols at the data link layer. It can be used to debug plaintext protocols, analyze anomalous network activity, and for security/hacking purposes. The document provides examples of ngrep commands and output, demonstrating how it can be used to inspect HTTP headers, filter traffic, and view output in both ASCII and hexadecimal formats.
Many applications are network I/O bound, including common database-based applications and service-based architectures. But operating systems and applications are often untuned to deliver high performance. This session uncovers hidden issues that lead to low network performance, and shows you how to overcome them to obtain the best network performance possible.
Kernel Recipes 2014 - NDIV: a low overhead network traffic diverterAnne Nicolas
NDIV is a young, very simple, yet efficient network traffic diverter. Its purpose is to help build network applications that intercept packets at line rate with a very low processing overhead. A first example application is a stateless HTTP server reaching line rate on all packet sizes.
Willy Tarreau, HaproxyTech
The document discusses Linux networking commands and tools. It provides examples of using ip commands to view and configure network interfaces, routes, neighbors, and rules. It also shows tcpdump for packet capture and nmap for port scanning. Firewalls are configured using iptables to allow traffic from a specific source to a web server port.
TensorFlow can be installed and run in a distributed environment using Docker. The document discusses setting up TensorFlow workers and parameter servers in Docker containers using a Docker compose file. It demonstrates building Docker images for each role, and configuring the containers to communicate over gRPC. A Jupyter server container is also built to host notebooks. The distributed TensorFlow environment is deployed locally for demonstration purposes. Future directions discussed include running the distributed setup on a native cluster using tools like Docker Swarm or RancherOS, and testing TensorFlow with GPU support in Docker.
CCNP Data Center Centralized Management Automation
POAP
UCS Director
Go to www.esgjrconsultinginc.com to learn more about Software/Network Engineering Projects.
This document discusses using Docker and Ansible together for infrastructure as code. It begins with an overview of problems with traditional deployment approaches and advantages of defining infrastructure programmatically. It then provides in-depth explanations of Docker concepts like images, containers, Dockerfiles and how Docker works. The remainder covers using Ansible for configuration management, explaining concepts like modules, inventory, playbooks and roles. It emphasizes that Docker and Ansible together provide an easy way to start automating infrastructure while removing dependencies on specific technologies.
The document describes a workshop on Xilinx Vivado High Level Synthesis (HLS) tools held at NECST. The agenda includes an introduction to hardware design flow, the Vivado HLS design flow, kernel creation and optimization, and a hands-on example of implementing a vector addition using Vivado HLS. The example takes the participants through various implementation versions to optimize the kernel by applying directives for loop pipelining, array partitioning, and memory optimizations.
VMworld 2016: vSphere 6.x Host Resource Deep DiveVMworld
1. This document provides an overview and agenda for a presentation on vSphere 6.x host resource deep dive topics including compute, storage, and network.
2. It introduces the presenters, Niels Hagoort and Frank Denneman, and provides background on their expertise.
3. The document outlines the topics to be covered under each section, including NUMA, CPU cache, DIMM configuration, I/O queue placement, driver considerations, RSS and NetQueue scaling for networking.
Non-blocking I/O, Event loops and node.jsMarcus Frödin
This 15 minute presentation discusses non-blocking I/O, event loops, and Node.js. It builds on previous work by Ryan Dahl, explaining how threads can be expensive due to context switching and memory usage, and how Node.js uses an event-driven, non-blocking model to avoid these costs. Code examples demonstrate getting and printing a policy object, handling HTTP requests asynchronously without blocking additional connections, and using callbacks to chain asynchronous actions together.
This document discusses network considerations for Real Application Clusters (RAC). It describes the different network types used, including public, private, storage, and backup networks. It discusses protocols like TCP and UDP used for different traffic. It also covers concepts like network architecture, layers, MTU, jumbo frames, and tools for monitoring network performance like netstat, ping, and traceroute.
gRPC is a modern open source RPC framework that enables client and server applications to communicate transparently. It is based on HTTP/2 for its transport mechanism and Protocol Buffers as its interface definition language. Some benefits of gRPC include being fast due to its use of HTTP/2, supporting multiple programming languages, and enabling server push capabilities. However, it also has some downsides such as potential issues with load balancing of persistent connections and requiring external services for service discovery.
Docker and friends at Linux Days 2014 in Praguetomasbart
Docker allows deploying applications easily across various environments by packaging them along with their dependencies into standardized units called containers. It provides isolation and security while allowing higher density and lower overhead than virtual machines. Core OS and Mesos both integrate with Docker to deploy containers on clusters of machines for scalability and high availability.
Many applications are network I/O bound, including common database-based applications and service-based architectures. But operating systems and applications are often untuned to deliver high performance. This session uncovers hidden issues that lead to low network performance, and shows you how to overcome them to obtain the best network performance possible.
HAProxy is a free, open-source load balancer and proxy server. It is fast, reliable, and widely used. Some common uses of HAProxy include load balancing HTTP traffic, using access control lists to route requests, handling HTTPS traffic, load balancing MySQL databases, and proxying SSH connections. The latest version of HAProxy introduced new features like connection tracking, limiting connections per IP address, and peer synchronization between HAProxy instances. HAProxy provides high performance, flexibility, and scalability for traffic routing and distribution.
Container orchestration from theory to practiceDocker, Inc.
"Join Laura Frank and Stephen Day as they explain and examine technical concepts behind container orchestration systems, like distributed consensus, object models, and node topology. These concepts build the foundation of every modern orchestration system, and each technical explanation will be illustrated using SwarmKit and Kubernetes as a real-world example. Gain a deeper understanding of how orchestration systems work in practice and walk away with more insights into your production applications."
Cómo hemos implementado semántica de "Exactly Once" en nuestra base de datos ...javier ramirez
Los sistemas distribuidos son difíciles. Los sistemas distribuidos de alto rendimiento, más. Latencias de red, mensajes sin confirmación de recibo, reinicios de servidores, fallos de hardware, bugs en el software, releases problemáticas, timeouts... hay un montón de motivos por los que es muy difícil saber si un mensaje que has enviado se ha recibido y procesado correctamente en destino. Así que para asegurar mandas el mensaje otra vez.. y otra... y cruzas los dedos para que el sistema del otro lado tenga tolerancia a los duplicados.
QuestDB es una base de datos open source diseñada para alto rendimiento. Nos queríamos asegurar de poder ofrecer garantías de "exactly once", deduplicando mensajes en tiempo de ingestión. En esta charla, te cuento cómo diseñamos e implementamos la palabra clave DEDUP en QuestDB, permitiendo deduplicar y además permitiendo Upserts en datos en tiempo real, añadiendo solo un 8% de tiempo de proceso, incluso en flujos con millones de inserciones por segundo.
Además, explicaré nuestra arquitectura de log de escrituras (WAL) paralelo y multithread. Por supuesto, todo esto te lo cuento con demos, para que veas cómo funciona en la práctica.
Daryaganj @ℂall @Girls ꧁❤ 9873777170 ❤꧂VIP Yogita Mehra Top Model Safe
CEPH中的QOS技术
1. Doing Quality of Service without QoS
David Byte
Sr. Technical Strategist
SUSE
Alex Lau
Storage Consultant
SUSE
2. The Challenge
Many customers desire Quality of Service.
● Traditional storage provides it
● Modern storage needs it
3. Current State of Affairs
There isn’t a mechanism in place for providing QoS today and
the ISCSI target providers don’t support this directly either.
There are multiple way to provide different forms of QoS.
● The client can limit their own read/write/iops.
● Control traffic at the gateway
● Traffic shaping via the network
● Ceph Native QoS
4. Upstream efforts
In the upstream community, work is ongoing to implement
QoS. But a distributed storage QoS is not easy to do. It also
involved with the dmclock implementation.
https://github.com/ceph/dmclock
https://github.com/ceph/ceph/pull/17450
5. Possible solutions for now
For RGW, load-balancers may provide some functionality
For other protocols, there isn’t much…
iscsi manipulate cmdsn_depth queue
tc (Traffic Control) is built into the Linux kernel and is able to
provide weighted queues similar to network QoS.
• Option 1 – bandwidth cap
• Option 2 – inject latency
6. Adjust ISCSI cmdsn_depth queue
This is not really QoS, but queue depth controls max I/O
● 1 queue depth size = slowest
● 64 = much faster
Pro:
Simple script to automate
Con:
Not exact
Minimum may still be too high
Adjustment by hand is still necessary
7. # First we need to get the target and initiator name
# e.g. /sys/kernel/config/target/iscsi/{target}
/tpgt_1/acls/{initiator}
if [ ! $1 ]; then
echo "Please provide target name to adjust speed"
exit -1
fi
TARGET=$1
if [ ! $2 ]; then
echo "Please provide initiator name to adjust
speed"
exit -1
fi
INITIATOR=$2
cmdsn_depth Sample Script
8. # Check target exist and Check ACL is enable
TARGET_PATH=/sys/kernel/config/target/iscsi/$TARGET
CMD_DEPTH_PATH=$TARGET_PATH/tpgt_1/acls/$INITIATOR/cmdsn_depth
if [ ! -f $TARGET_PATH ]; then
if [ ! -d $TARGET_PATH/tpgt_1/acls ]; then
echo "Target need acl to allow throlle to work"
exit -1
else
if [ ! -f $CMD_DEPTH_PATH ]; then
echo "Initiator throttler controller
doesn't exist"
exit -1
Check target and ACL
9. echo "Please enter [min max] to adjust speed ?"
select result in "min" "max"; do
case $result in
"min" ) echo 1 > $CMD_DEPTH_PATH ;
echo "Now $INITIATOR running at slowest speed"
break;;
"max" ) echo 64 > $CMD_DEPTH_PATH ;
echo "Now $2 should be running at fastest speed"
break;;
esac
done
Script to set cmdsn_depth
10. How did I monitor the results?
With openATTIC and Grafana Prometheus and node_exporter, we
can monitor the iscsi read, write and ops more easily.
However the module still currently in PR waiting to get into prometheus.
https://github.com/prometheus/procfs/pull/69
https://github.com/prometheus/node_exporter/pull/776
12. Use tc to control bandwidth
Can filter based on source IP address or target IP address
tc qdisc add dev eth0 root handle 1: htb default 30
tc class add dev eth0 parent 1: classid 1:1 htb rate 10000mbit burst 15m
tc class add dev eth0 parent 1:1 classid 1:10 htb rate 5000mbit burst 15m
tc class add dev eth0 parent 1:1 classid 1:20 htb rate 3000mbit burst 15m
tc class add dev eth0 parent 1:1 classid 1:30 htb rate 100mbit ceil 9000mbit burst 15m
The author then recommends SFQ for beneath these classes:
tc qdisc add dev eth0 parent 1:10 handle 10: sfq perturb 10
tc qdisc add dev eth0 parent 1:20 handle 20: sfq perturb 10
tc qdisc add dev eth0 parent 1:30 handle 30: sfq perturb 10
#Filter based on destination (iscsi target) IP
tc filter add dev eth0 parent 1:0 protocol ip prio 1 u32 match ip dst 4.3.2.1/32 flowid 1:10
#Filter based on source (iscsi initiator) IP
tc filter add dev eth0 parent 1:0 protocol ip prio 1 u32 match ip src 1.2.3.4/32 flowid 1:10
13. Use tc to inject latency
tc qdisc add dev eth0 root handle 1: prio
tc qdisk add dev eth0 parent 1:1 handle 10: netem delay .05ms
#Filter based on destination (iscsi target) IP
tc filter add dev eth0 parent 1:0 protocol ip prio 1 u32 match ip dst 4.3.2.1/32 flowid 1:1
#Filter based on source (iscsi initiator) IP
tc filter add dev eth0 parent 1:0 protocol ip prio 1 u32 match ip src 1.2.3.4/32 flowid 1:1
14. tc Methods Pros & Cons
Pros:
Better control for bandwidth
Easily managed through salt or ansible
Cons:
tc is complex
Not the easiest to use (hundreds of clients = high complexity)
It doesn’t control IOPS
Packets can get dropped
Thoughts:
Use multiple subnets for ISCSI initiators. Each subnet has it’s own filter and
thus QoS setting. This only makes sense with injected delays
15. Our thoughts and recommendations
If possible, wait for upstream to provide a ceph native solution.
If not, carefully select, test, and implement a solution that works for your
particular use case.