https://stripe.com/blog/secret-life-of-dns * Products * Solutions * Developers * Resources * Pricing Contact sales Dashboard Sign in Sign in Back * Products * Solutions * Developers * Resources * Contact sales * Pricing Global payments * Payments Online payments + Payment Links No-code payments + Checkout Prebuilt payment form + Elements Flexible UI components * Terminal In-person payments * Radar Fraud prevention * Authorization Acceptance optimizations Embedded payments and Finance * Connect Payments for platforms * Treasury Financial accounts * Capital Customer financing * Issuing Physical and virtual cards Revenue and Finance Automation * Billing Subscriptions and usage-based * Revenue Recognition Accounting automation * Tax Sales tax & VAT automation * Invoicing Online invoices * Sigma Custom reports * Data Pipeline Data sync More + Payment methods Access to 100+ globally + Link Accelerated checkout + Financial Connections Linked financial account data + Identity Online identity verification + Atlas Startup incorporation By stage * Enterprises * Startups By business model * Ecommerce * SaaS * Platforms * Marketplaces By use case * Finance automation * Embedded finance * Global businesses * Crypto * Creator economy * Retail Ecosystem * Stripe App Marketplace * Partners * Professional services * Documentation Get started * Prebuilt checkout * Libraries and SDKs * App integrations Guides * Accept online payments * Manage subscriptions * Send payments * Full API reference * API status * API changelog * Build on Stripe Apps * Support center * Support plans * Guides * Customer stories * Blog * Sessions * Contact sales * Jobs * Newsroom * Stripe Press * Become a partner Sign in Global payments * Payments Online payments + Payment Links No-code payments + Checkout Prebuilt payment form + Elements Flexible UI components * Terminal In-person payments * Radar Fraud prevention * Authorization Acceptance optimizations Embedded payments and Finance * Connect Payments for platforms * Treasury Financial accounts * Capital Customer financing * Issuing Physical and virtual cards Revenue and Finance Automation * Billing Subscriptions and usage-based * Revenue Recognition Accounting automation * Tax Sales tax & VAT automation * Invoicing Online invoices * Sigma Custom reports * Data Pipeline Data sync More * Payment methods Access to 100+ globally * Link Accelerated checkout * Financial Connections Linked financial account data * Identity Online identity verification * Atlas Startup incorporation By stage * Enterprises * Startups By business model * Ecommerce * SaaS * Platforms * Marketplaces By use case * Finance automation * Embedded finance * Global businesses * Crypto * Creator economy * Retail Ecosystem * Stripe App Marketplace * Partners * Professional services * Documentation Start integrating Stripe's products and tools Get started * Prebuilt checkout * Libraries and SDKs * App integrations * Code samples Guides * Accept online payments * Manage subscriptions * Send payments * Set up in-person payments * Full API reference * API status * API changelog * Build on Stripe Apps * Support center * Support plans * Guides * Customer stories * Blog * Sessions * Contact sales * Chat With Us * Jobs * Newsroom * Stripe Press * Become a partner 1. Blog 2. Engineering Stripe on Twitter The secret life of DNS packets: investigating complex networks May 21, 2019 [jeffj] Jeff Jo API Services DNS is a critical piece of infrastructure used to facilitate communication across networks. It's often described as a phonebook: in its most basic form, DNS provides a way to look up a host's address by an easy-to-remember name. For example, looking up the domain name stripe.com will direct clients to the IP address 53.187.159.182, where one of Stripe's servers is located. Before any communication can take place, one of the first things a host must do is query a DNS server for the address of the destination host. Since these lookups are a prerequisite for communication, maintaining a reliable DNS service is extremely important. DNS issues can quickly lead to crippling, widespread outages, and you could find yourself in a real bind. It's important to establish good observability practices for these systems so when things go wrong, you can clearly understand how they're failing and act quickly to minimize any impact. Well-instrumented systems provide visibility into how they operate; establishing a monitoring system and gathering robust metrics are both essential to effectively respond to incidents. This is critical for post-incident analysis when you're trying to understand the root cause and prevent recurrences in the future. In this post, I'll describe how we monitor our DNS systems and how we used an array of tools to investigate and fix an unexpected spike in DNS errors that we encountered recently. DNS infrastructure at Stripe At Stripe, we operate a cluster of DNS servers running Unbound, a popular open-source DNS resolver that can recursively resolve DNS queries and cache the results. These resolvers are configured to forward DNS queries to different upstream destinations based on the domain in the request. Queries that are used for service discovery are forwarded to our Consul cluster. Queries for domains we configure in Route 53 and any other domains on the public Internet are forwarded to our cluster's VPC resolver, which is a DNS resolver that AWS provides as part of their VPC offering. We also run resolvers locally on every host, which provides an additional layer of caching. diagram Unbound runs locally on every host as well as on the DNS servers. Unbound exposes an extensive set of statistics that we collect and feed into our metrics pipeline. This provides us with visibility into metrics like how many queries are being served, the types of queries, and cache hit ratios. chart1 chart2 chart3 chart4 We recently observed that for several minutes every hour, the cluster's DNS servers were returning SERVFAIL responses for a small percentage of internal requests. SERVFAIL is a generic response that DNS servers return when an error occurs, but it doesn't tell us much about what caused the error. chart5 Without much to go on initially, we found another clue in the request list depth metric. (You can think of this as Unbound's internal todo list, where it keeps track of all the DNS requests it needs to resolve.) chart6 An increase in this metric indicates that Unbound is unable to process messages in a timely fashion, which may be caused by an increase in load. However, the metrics didn't show a significant increase in the number of DNS queries, and resource consumption didn't appear to be hitting any limits. Since Unbound resolves queries by contacting external nameservers, another explanation could be that these upstream servers were taking longer to respond. Tracking down the source We followed this lead by logging into one of the DNS servers and inspecting Unbound's request list. $ unbound-control dump_requestlist thread #0 # type cl name seconds module status 0 A IN s3.amazonaws.com. - iterator wait for 10.0.0.2 1 PTR IN 3.8.25.104.in-addr.arpa. - iterator wait for 10.0.0.2 2 PTR IN 5.101.25.104.in-addr.arpa. - iterator wait for 10.0.0.2 3 PTR IN 5.156.25.104.in-addr.arpa. - iterator wait for 10.0.0.2 4 PTR IN 123.71.25.104.in-addr.arpa. - iterator wait for 10.0.0.2 5 PTR IN 212.28.24.104.in-addr.arpa. - iterator wait for 10.0.0.2 6 PTR IN 18.81.25.104.in-addr.arpa. - iterator wait for 10.0.0.2 7 PTR IN 103.78.24.104.in-addr.arpa. - iterator wait for 10.0.0.2 8 PTR IN 22.43.25.104.in-addr.arpa. - iterator wait for 10.0.0.2 9 PTR IN 24.17.25.104.in-addr.arpa. - iterator wait for 10.0.0.2 10 PTR IN 21.100.25.104.in-addr.arpa. - iterator wait for 10.0.0.2 ... ... ~ This confirmed that requests were accumulating in the request list. We noticed some interesting details: most of the entries in the list corresponded to reverse DNS lookups (PTR records) and they were all waiting for a response from 10.0.0.2, which is the IP address of the VPC resolver. We then used tcpdump to capture the DNS traffic on one of the servers to get a better sense of what was happening and try to identify any patterns. We wanted to make sure we captured the traffic during one of these spikes, so we configured tcpdump to write data to files over a period of time. We split the files across 60 second collection intervals to keep file sizes small, which made it easier to work with them. # Capture all traffic on port 53 (DNS traffic) # Write data to files in 60 second intervals for 30 minutes # and format the filenames with the current time $ tcpdump -n -tt -i any -W 30 -G 60 -w '%FT%T.pcap' port 53 ~ The packet captures revealed that during the hourly spike, 90% of requests made to the VPC resolver were reverse DNS queries for IPs in the 104.16.0.0/12 CIDR range. The vast majority of these queries failed with a SERVFAIL response. We used dig to query the VPC resolver with a few of these addresses and confirmed that it took longer to receive responses. By looking at the source IPs of clients making the reverse DNS queries, we noticed they were all coming from hosts in our Hadoop cluster. We maintain a database of when Hadoop jobs start and finish, so we were able to correlate these times to the hourly spikes. We finally narrowed down the source of the traffic to one job that analyzes network activity logs and performs a reverse DNS lookup on the IP addresses found in those logs. One more surprising detail we discovered in the tcpdump data was that the VPC resolver was not sending back responses to many of the queries. During one of the 60-second collection periods the DNS server sent 257,430 packets to the VPC resolver. The VPC resolver replied back with only 61,385 packets, which averages to 1,023 packets per second. We realized we may be hitting the AWS limit for how much traffic can be sent to a VPC resolver, which is 1,024 packets per second per interface. Our next step was to establish better visibility in our cluster to validate our hypothesis. Counting packets AWS exposes its VPC resolver through a static IP address relative to the base IP of the VPC, plus two (for example, if the base IP is 10.0.0.0, then the VPC resolver will be at 10.0.0.2). We need to track the number of packets sent per second to this IP address. One tool that can help us here is iptables, since it keeps track of the number of packets matched by a rule. We created a rule that matches traffic headed to the VPC resolver IP address and added it to the OUTPUT chain, which is a set of iptables rules that are applied to all packets sent from the host. We configured the rule to jump to a new chain called VPC_RESOLVER and added an empty rule to that chain. Since our hosts could contain other rules in the OUTPUT chain, we added this rule to isolate matches and make it a little easier to parse the output. Listing the rules, we see the number of packets sent to the VPC resolver in the output: $ iptables -L -v -n -x Chain OUTPUT (policy ACCEPT 41023 packets, 2569001 bytes) pkts bytes target prot opt in out source destination 41023 2569001 VPC_RESOLVER all -- * * 0.0.0.0/0 10.0.0.2 Chain VPC_RESOLVER (1 references) pkts bytes target prot opt in out source destination 41023 2569001 all -- * * 0.0.0.0/0 0.0.0.0/0 ~ With this, we wrote a simple service that reads the statistics from the VPC_RESOLVER chain and reports this value through our metrics pipeline. while : do PACKET_COUNT=$(iptables -L VPC_RESOLVER 1 -x -n -v | awk ' { print $1 }') report-metric $PACKET_COUNT "vpc_resolver.packet_count" sleep 1 done ~ Once we started collecting this metric, we could see that the hourly spikes in SERVFAIL responses lined up with periods where the servers were sending too much traffic to the VPC resolver. chart7 Traffic amplification The data we saw from iptables (the number of packets per second sent to the VPC resolver) indicated a significant increase in traffic to the VPC resolvers during these periods, and we wanted to better understand what was happening. Taking a closer look at the shape of the traffic coming into the DNS servers from the Hadoop job, we noticed the clients were sending the request five times for every failed reverse lookup. Since the reverse lookups were taking so long or being dropped at the server, the local caching resolver on each host was timing out and continually retrying the requests. On top of this, the DNS servers were also retrying requests, leading to request volume amplifying by an average of 7x. diagram Spreading the load One thing to remember is that the VPC resolver limit is imposed per network interface. Instead of performing the reverse lookups solely on our DNS servers, we could instead distribute the load and have each host contact the VPC resolver independently. With Unbound running on each host we can easily control this behavior. Unbound allows you to specify different forwarding rules per DNS zone. Reverse queries use the special domain in-addr.arpa, so configuring this behavior was a matter of adding a rule that forwards requests for this zone to the VPC resolver. We knew that reverse lookups for private addresses stored in Route 53 would likely return faster than reverse lookups for public IPs that required communication with an external nameserver. So we decided to create two forwarding configurations, one for resolving private addresses (the 10.in-addr.arpa. zone) and one for all other reverse queries (the .in-addr.arpa. zone). Both rules were configured to send requests to the VPC resolver. Unbound calculates retry timeouts based on a smoothed average of historical round trip times to upstream servers and maintains separate calculations per forwarding rule. Even if two rules share the same upstream destination the retry timeouts are computed independently, which helps isolate the impact of inconsistent query performance on timeout calculations. After applying the forwarding configuration change to the local Unbound resolvers on the Hadoop nodes we saw that the hourly load spike to the VPC resolvers had gone away, eliminating the surge of SERVFAILS we were seeing: chart8 Adding the VPC resolver packet rate metric gives us a more complete picture of what's going on in our DNS infrastructure. It alerts us if we approach any resource limits and points us in the right direction when systems are unhealthy. Some other improvements we're considering include collecting a rolling tcpdump of DNS traffic and periodically logging the output of some of Unbound's debugging commands, such as the contents of the request list. Visibility into complex systems When operating such a critical piece of infrastructure like DNS, it's crucial to understand the health of the various components of the system. The metrics and command line tools that Unbound provides gives us great visibility into one of the core components of our DNS systems. As we saw in this scenario, these types of investigations often uncover areas where monitoring can be improved, and it's important to address these gaps to better prepare for incident response. Gathering data from multiple sources allows you to see what's going on in the system from different angles, which can help you narrow in on the root cause during an investigation. This information will also identify if the remediations you put in place have the intended effect. As these systems grow to handle more scale and increase in complexity, how you monitor them must also evolve to understand how different components interact with each other and build confidence that your systems are operating effectively. Subscribe to the Stripe Blog Stay connected with Stripe and receive new blog posts in your inbox. [ ] Something went wrong on our end. Sorry about that. You can still contact us at sales@stripe.com. We're sorry, but we're unable to serve your request. Subscribe Stripe will handle your data pursuant to its Privacy Policy By submitting this form, you acknowledge and consent that your personal data will be processed in accordance with Stripe's Privacy Policy and that your data will be stored outside of China in accordance with Stripe's Privacy Policy. Thank you for subscribing. You'll receive blog updates in your inbox soon. Like this post? Join our team. Stripe builds financial tools and economic infrastructure for the internet. View roles Have any feedback or questions? We'd love to hear from you. Contact us United States (English) * AU Australia + English * AT Austria + Deutsch + English * BE Belgium + Nederlands + Francais + Deutsch + English * BR Brazil + Portugues + English * BG Bulgaria + English * CA Canada + English + Francais * HR Croatia + English + Italiano * CY Cyprus + English * CZ Czech Republic + English * DK Denmark + English * EE Estonia + English * FI Finland + English + Svenska * FR France + Francais + English * DE Germany + Deutsch + English * GI Gibraltar + English * GR Greece + English * HK Hong Kong + English + Jian Ti Zhong Wen * HU Hungary + English * IN India + English * IE Ireland + English * IT Italy + Italiano + English * JP Japan + Ri Ben Yu + English * LV Latvia + English * LI Liechtenstein + Deutsch + English * LT Lithuania + English * LU Luxembourg + Francais + Deutsch + English * MY Malaysia + English + Jian Ti Zhong Wen * MT Malta + English * MX Mexico + Espanol + English * NL Netherlands + Nederlands + English * NZ New Zealand + English * NO Norway + English * PL Poland + English * PT Portugal + Portugues + English * RO Romania + English * SG Singapore + English + Jian Ti Zhong Wen * SK Slovakia + English * SI Slovenia + English + Italiano * ES Spain + Espanol + English * SE Sweden + Svenska + English * CH Switzerland + Deutsch + Francais + Italiano + English * TH Thailand + aithy + English * AE United Arab Emirates + English * GB United Kingdom + English * United States + English + Espanol + Jian Ti Zhong Wen Products & pricing * Pricing * Atlas * Billing * Capital * Checkout * Climate * Connect * Data Pipeline * Elements * Financial Connections * Identity * Invoicing * Issuing * Link * Payments * Payment Links * Payouts * Radar * Revenue Recognition * Sigma * Tax * Terminal * Treasury Solutions * Startups * Enterprises * SaaS * Platforms * Ecommerce * Marketplaces * Crypto * Creator economy * Retail * Embedded finance * Global businesses * Finance automation Integrations & custom solutions * Stripe App Marketplace * Partner ecosystem * Professional services Developers * Documentation * API reference * API status * API changelog * Stripe Apps Resources * Guides * Customer stories * Blog * Annual conference * Privacy & terms * Prohibited & restricted businesses * Licenses * Sitemap * Cookie settings * Your privacy choices Company * Jobs * Newsroom * Stripe Press Support * Contact sales * Chat with us * Support center * Support plans * CA residents: +1 888 926 2289 * (c) 2024 Stripe, Inc.