DEV Community: Globalping

8 Self-hosted Projects You Can Run at home

Dmitriy A. — Fri, 13 Feb 2026 14:27:35 +0000

Running your own infrastructure at home is easier than ever. With Docker and an old Raspberry Pi or small server, you can host all kinds of fun and useful tools and have them all under your control.

Self-hosting can help you save on subscription fees, gain privacy and flexibility, and can even become a fun hobby. In this blog post, we'll explore eight open source projects you can run yourself, whether on a spare laptop or a rented VPS.

Memos

What it is:
Memos is a lightweight, open source note-taking platform that's great for capturing quick thoughts, todos, and knowledge snippets. It supports Markdown and can be easily deployed with Docker, making it a great choice for running on your home server.

Why it's great:

100% private: because you host it yourself, there's no third-party tracking or analytics
Markdown-based: all your notes stay portable and easy to migrate to other Markdown-based tools
Free and open source: all features and future updates are available without spending a cent
Flexible use: works great as a personal notebook or a small team knowledge base

Using Memos is a simple way to replace cloud-based notes apps with something you fully host yourself. For example, you could run it as your private daily log or idea archive, and access it from anywhere on your home network.

There’s also a demo available:

Globalping

What it is:
Globalping is a network measurement platform that lets you run commands like ping, mtr, dig, and http from locations around the world. This is possible because it relies on a distributed network of community-hosted probes that run these commands.
When you host a probe, it automatically joins the Globalping network and can be selected by the Globalping API to execute a user's measurement request.

Why it's great:

Secure: Probes only communicate with the Globalping API and block potentially dangerous domains and IP ranges
Earn credits: you can adopt your probe in the free Globalping Dashboard and earn credits for running it, which you can use for additional tests beyond the API rate limits
Multiple integrations: Run tests via the CLI, Slack app, MCP server, n8n node, directly through the API, or other available integrations.
Real-world learning: if you're interested in networking, hosting a probe, and experimenting with the Globalping platform is a great way to get practical experience

If you already use Globalping, running a probe is a great way to give back to the community and help improve the platform's global coverage and reliability.

Once adopted, you can view and manage probes in the Globalping Dashboard:

n8n

What it is:
n8n is a workflow automation tool that lets you connect apps and APIs through a visual interface. You can build automated workflows by linking triggers, actions, and logic.

Why it's great:

Visual builder: "draw" workflows by connecting nodes (apps) and filling out forms to configure them
No per-task fees: with the self-hosted version, you can create as many projects, users, and workflows as you like without paying a fee
Extensible: n8n provides hundreds of built-in nodes, and you can also write custom JavaScript and implement complex logic yourself

As an open-source, self-hosted platform, n8n lets you automate interactions between your own services (such as the tools mentioned in this post) without relying on a SaaS platform. For example, you could use it to build a simple monitoring solution for your API, combining a schedule trigger with Globalping to send HTTP requests to your API and send a Slack alert if any problems occur:

ConvertX

What it is:
ConvertX is a self-hosted file conversion service that supports over 1000 formats for video, audio, images, and documents. It runs in Docker and uses industry-standard converters such as FFmpeg, Pandoc, and ImageMagick for a wide range of converting options and high-quality results.

Why it's great:

Privacy-first: your files stay within your infrastructure, and you don't need to share sensitive data with third parties
Bulk processing: convert large batches of files without upload or bandwidth limits
Configurable: environment variables make it easy to adjust your setup

If you regularly convert media or documents and don't want to rely on online converters, ConvertX gives you full control. For example, you could batch-convert video files for your home media server or automatically transform Markdown files into PDFs using an n8n workflow.

Zipline

What it is:
Zipline is a fast file-sharing and URL shortening platform. It includes a dashboard, file gallery, metrics, and support for custom domains.

Why it's great:

Clean dashboard: manage uploads, folders, and links from one interface
Authentication options: supports OAuth providers, 2FA, passkeys, and password-protected files and URLs
Custom domains and vanity URLs: share files under your own branding
Team-friendly: invite others and configure their upload limits

Zipline is a good choice if you frequently share files and want full control over storage, links, and branding. For example, you could convert a file with ConvertX and automatically upload it to Zipline, generating a short link for sharing with n8n.

BentoPDF

What it is:
BentoPDF is a PDF toolkit focused on your privacy that you can self-host. It comes with a bunch of essential PDF editing and processing tools via a browser-based interface. Like with ConvertX, files never leave your device, and there are no file-size limits or other caps.

Why it's great:

Rich feature set: merge, split, compress, edit, sign, crop, and more
Workflow builder: create PDF workflows using a visual node editor
Well documented: you can find everything you need to know and more about BentoPDF on their GitHub page, with links to tutorials and documentation
Clear licensing: AGPL-3.0 for open source and personal use, and a commercial license for proprietary applications (one-time payment)

If you regularly work with documents and want a self-hosted alternative to online PDF tools, BentoPDF is a strong option. You could combine it with ConvertX and n8n to automate your document processing workflows.

You can also use the tools on the BentoPDF website to give it a try. Here’s a peek at the workflow builder:

OpenGist

What it is:
OpenGist is a self-hosted pastebin service powered by Git that lets you create, version, and share code or text snippets.

Why it's great:

Git-powered: clone, pull, and push snippets like a regular repository
Revision history: it tracks every change you make to your snippets
Access control: control visibility, manage signups, and configure OAuth2
Developer-friendly editor: supports syntax highlighting, indentation options, and drag-and-drop file uploads

If you frequently store configuration snippets, scripts, or small code examples, OpenGist keeps them versioned and under your control. For example, you could use it to host reusable configuration snippets without putting them on a public platform.

If you want to try it out first, you can find a demo here:

Beszel

What it is:
Beszel is a lightweight server monitoring solution with a central hub and small agents you install on the systems you want to monitor. It provides a clean web interface and works well in small home setups.

Why it's great:

Easy setup: simple configuration and quick deployment
Resource-efficient: runs great on most devices, such as your old Raspberry Pi
Container insights: shows CPU, memory, and network usage for each Docker container
Multi-user and API support: includes OAuth authentication and API access

Beszel lets you easily monitor multiple services at home, without the complexity of big monitoring systems. For example, you could monitor your Docker containers, home server, and Raspberry Pi from a single dashboard.

Conclusion

Self-hosting projects can be both fun and practical. With just a small server and Docker, you can run note-taking apps, automation platforms, monitoring tools, file converters, and even contribute to a global measurement network.

To run your own Globalping probe, visit GitHub for the repository and setup instructions:
https://github.com/jsdelivr/globalping-probe

Geolocate any IP using latency

Dmitriy A. — Mon, 15 Dec 2025 19:24:56 +0000

TLDR: I made a CLI tool that can resolve an IP address to a country, US state and even a city. https://github.com/jimaek/geolocation-tool
It works well and confirms ipinfo's findings.

Recently, I read how ipinfo finally proved what most technical people assumed: VPN providers don't actually maintain a crazy amount of infrastructure in hundreds of countries. They simply fake the IP geolocation by intentionally providing wrong location data to ARIN, RIPE, and Geo DB providers via geofeeds.

They achieved their results using a novel approach compared to other geo IP providers. Based on their blog and HackerNews comments, they built a large probe network and used it to trace and ping every (or most) IP addresses on the internet.

This latency and hop data, most likely along with advanced algorithms and data cross-reference, provides a reliable way of correctly detecting the physical geolocation of an IP address, without relying on faked data available in public sources.

This is a very interesting approach that makes total sense, and I'm sure their clients appreciate it and heavily rely on it.

While I can't ping every single IP address on the internet from hundreds of locations just yet, I can do it to a limited subset using Globalping. So I decided to try it out and see if I can replicate their results and build a small tool to allow anyone to do the same.

Globalping is an open-source, community-powered project that allows users to self-host container-based probes. These probes then become part of our public network, which allows anyone to use them to run network testing tools such as ping and traceroute.

At the moment, the network has more than 3000 probes, which in theory should be plenty to geolocate almost any IP address down to a country and even a US state level.

To automate and simplify this process, I made a little CLI tool using the globalping-ts library. My original idea was simple:

Accept a single IP as input
Ping it a few times per continent to select the continent
Then ping the IP from many different probes on that continent
Group and sort the results; the country with the lowest latency should be the correct one
And as a bonus, repeat the same process for USA states if the winning country was the US

Essentially, what I had to do was simply create a few measurements and pass the location I needed using Globalping’s magic field, which would automatically figure out what I was looking for and select a few pseudo-random probes that fit the location and limit.

Now initially, I used ping with 2 packets to run all measurements as quickly as possible, but I quickly realized it wasn’t a good idea as most networks block ICMP traffic. Next, I tried switching to TCP-based ping, which required trying a few popular ports to get it to work. I quickly realized this was too complicated and unreliable and switched to traceroute.

It worked perfectly. Even though traceroute uses ICMP by default, it did not matter to me if the target IP’s network allowed ICMP or not, I simply analyzed the latency of the last available hop. Even if you block ICMP, your upstream most likely allows it, and in most cases, it’s located in the same country.

Of course, this means the resulting data is not 100% perfect. A better approach would be to analyze each IP using different methods, including TCP and UDP-based traceroute on different ports, and expand to the last few hops instead of just one. Maybe even try to figure out the location of the registered ASNs and use a weights system in combination with public whois info in order to “vote” for the right location based on different inputs. Probably even mark low certainty IPs to be retested with a double amount of probes. (end of rant)

But that’s something for a commercial provider to figure out, which it seems they did.

For continent detection, I decided to use just 5 probes per continent; the results were extremely accurate. Although for IPs just on the "border" of continents it might be ineffective, a higher amount of probes would generate better results. For this use case, it was good enough.

My home IP in central Europe was too easy to detect:

Phase 1: Detecting continent...
  North America: 137.18 ms
  Europe: 32.39 ms
  Asia: 174.54 ms
  South America: 215.08 ms
  Oceania: 244.15 ms
  Africa: 156.83 ms

In phase 2, all we need to do is run a single measurement with the winning continent as the location and a higher limit. Initially, I started with 250 probes with great accuracy.

Eventually, I decided to drop down to 50 as the default. Based on my tests, the results continued to look really good, and it would allow the tool to be run even without authentication, as the Globalping API allows 250 tests per hour per IP and 50 probes per measurement.

Although I recommend registering for a free account at https://dash.globalping.io/ and authenticating with a token to get up to 500 tests per hour and run more tests.

Note: If you need more tests than that, you can either host a probe to generate passive credits to be used as tests, or donate via GitHub Sponsors. We will automatically detect it and credit your account.

Phase 2: Detecting country...
  Measuring from 50 probes...

  [████████████████████████████████████████] 100.0%   50/50 - Best: PL (7.29 ms)                    

Top 3 Locations:
─────────────────────────────────────────────────
  1.. Poland, EU                               7.29 ms
  2.. Germany, EU                              13.42 ms
  3.. Lithuania, EU                            17.65 ms

═══════════════════════════════════════════════════
                      SUMMARY
═══════════════════════════════════════════════════
  Location: Poland, EU
  Minimum Latency: 7.29 ms
  Confidence: Medium

Great, now we have a basic IP-to-country resolver that only takes a few seconds to provide a response, and I didn’t even have to understand or write any complicated math. Although I’m sure someone smarter could use a formula to geolocate IPs with even fewer probes and higher accuracy.

For phase 3, we want to resolve the US to a specific state or territory, just like ipinfo did, and luckily they even provided a few sample IPs and locations to benchmark against during testing.

Again, this was as simple as creating a new measurement with the USA as the location. I used 50 probes as the default limit and tested the NordVPN IP advertised as Bahamas but resolved to Miami by ipinfo.

Phase 3: Detecting US state...
  Measuring from 50 probes...

  [████████████████████████████████████████] 100.0%   50/50 - Best: FL (0.45 ms)                    

Top 3 Locations:
─────────────────────────────────────────────────
  1. Florida, USA                             0.45 ms
  2. South Carolina, USA                      12.23 ms
  3. Georgia, USA                             15.01 ms

═══════════════════════════════════════════════════
                      SUMMARY
═══════════════════════════════════════════════════
  Location: Florida, United States
  Minimum Latency: 0.45 ms
  Confidence: Very High
═══════════════════════════════════════════════════

The tool agrees, Florida is the correct location. But how accurate can this system be? Can we expand it to show the city too?

Let's make a new phase, which again, will simply set the resulting country or state as the location and extract the city of the probe with the lowest latency. Here, since there are too many possible cities and towns per state and country, I expect the accuracy to be low and only point to the closest major hub. But in theory, this should be more than enough for use cases like routing or performance debugging.

And here we go, the same result ipinfo got

Phase 4: Detecting city...
  Measuring from 36 probes...

  [████████████████████████████████████████] 100.0%   36/36 - Best: Miami (0.00 ms)                 

Top 3 Locations:
─────────────────────────────────────────────────
  1. Miami, Florida, USA                      0.00 ms
  2. West Palm Beach, Florida, USA            4.36 ms
  3. Tampa, Florida, USA                      5.85 ms

═══════════════════════════════════════════════════
                      SUMMARY
═══════════════════════════════════════════════════
  Location: Miami, Florida, United States
  Minimum Latency: 0.00 ms
  Confidence: Very High
═══════════════════════════════════════════════════

The current results are good but could be better. The main problem is with how the magic field works: when setting, for example, 'Europe' as the location, it tries to spread the tests across all European probes but does not guarantee that every single country is going to be included.

This results in inconsistencies where a probe in the same country as the target IP was not selected, and so the tool assumes the IP is located in a different neighbouring country.

To fix this and make the results more consistent, you would need to change the selection logic and manually set every country per continent and US state. By passing the full list of countries/states to the Globalping API, you ensure that at least one probe in that location is going to be selected. Additionally, you fully control the number of probes per location, which is very important to control the accuracy.

For example, North America technically contains 43 countries and territories. This means you can't just set a limit of one probe per country, it is not enough to properly understand the latency to the target IP from the disproportionately larger USA. A better limit would be around 200 probes for the USA, 20 for Canada, and 10 for Mexico.

But the goal of this tool was to use a minimum amount of probes to allow unauthenticated users to test it out. The current approach works great, it is simple to implement and it is very easy to control the accuracy by simply setting a higher limit of probes.

Overall, latency-based geolocation detection seems to be a great way to verify the location of any IP as long as you have enough vantage points. It will most likely fall apart in regions with minimal or no coverage.

The tool itself is open source and you can run it like this:

geolocate $IP

You can also use the –limit parameter to use more probes per phase. But be careful as it applies the set value to all phases and this will very quickly eat through your limit. Check the full docs in GitHub.

Pull requests with improvements are welcome!

Feel free to email me if you need some free credits to play around with d@globalping.io

And of course consider hosting a probe, it’s as simple as running a container https://github.com/jsdelivr/globalping-probe

Automate Uptime Monitoring with Zapier and Globalping

Dmitriy A. — Wed, 19 Mar 2025 15:16:53 +0000

If you're tired of manually checking if your website or API is up and are looking for a simple, budget-friendly way to automate uptime monitoring, you're in the right place.

In this guide, we will create a simple uptime monitoring setup using Zapier and Globalping. By the end, you will have a Zap that:

automatically runs an HTTP test on your website or web service
sends a notification to Slack when a test fails
uses AI to summarize the failed test results and emails them to you

About the tools

Let's briefly introduce the tools we'll be using:

Zapier is a workflow automation tool that lets you connect triggers, functionality, and apps to build "Zaps" to take care of all kinds of processes, giving you back valuable time for more important tasks.
Globalping is an open-source network testing platform that allows you to run measurements like ping, mtr, and dig from anywhere in the world. The platform uses thousands of probes hosted by the community and partners to run these tests. Globalping gives you access to testing locations you wouldn't normally have, and it's free.

Prerequisites

To follow this guide, you'll need:

a Zapier Pro subscription and familiarity with the tool
a Globalping account
the ability to run a cron job to trigger your Zap

Step 1 – Automate uptime testing

Let's start building the foundation of our Zap by automating our uptime checks. To do this, we'll create a new Zap, add a schedule, and use Globalping to run an HTTP test on your target URL.

How can Globalping help with uptime checks?

You can perform tests like ping, mtr, traceroute, dns (dig), and http to assess, troubleshoot, and benchmark your network. For uptime monitoring, we'll create an HTTP GET request. The test's result tells us whether the target website is up and provides other useful data, such as performance metrics and TLS certificate information, which you can use later in your Zap.

Setting up the Zap

In your Zapier dashboard, create a new Zap
Create the trigger
1. Search for and select the "Webhook by Zapier" app
2. Set "Trigger event" as "Catch Hook"
3. Leave the "Configure" tab as is
Test the trigger
1. In the "Test" tab, you can find the Zapier webhook URL – calling it starts the Zap
2. Create a cron job on your server, third-party service, or wherever you want to call the webhook URL at your desired frequency. In this example, I set the frequency to 3 minutes:\ */3 * * * * curl https://hooks.zapier.com/catch/123

Note: If you prefer, you can use the "Schedule app by Zapier", which can run the uptime check once per hour. This is handy if you don't want to create a cron job or if hourly testing is enough for your use case.

Adding Globalping to run HTTP tests to our Zap

Create the first action
1. Search for and select the "Globalping" app
2. Set "Action Event" as "HTTP Request"
3. Connect your Globalping Dashboard account!
Configure the Globalping HTTP test
1. Target URL: Enter the URL you want to monitor. I'll use the Globalping homepage https://globalping.io
2. Location: Choose the location from which you want to run the tests. I'll define "World" here, which will randomly pick a location for me. You can learn more about providing locations on GitHub.
3. Limit: Set the number of tests to run. Let's set it to one (1)
4. Request type: Select "GET"
5. HTTP Headers: Add as needed!
Test the Globalping HTTP test
1. Run a test to make sure everything is working as expected and to see the data Globalping returns.

How much will this cost you?

Globalping comes with generous limits with up to 250 free tests and 50 probes per measurement for unregistered users. When you sign up to the Globalping Dashboard, these limits increase to 500 tests per hour and 500 probes per measurement at no cost.

For most users, these free limits are sufficient. If you need more, Globalping has a credit system where you can earn credits by hosting probes or sponsoring the project. Check the Globalping website for more details.

Step 2 - Send Slack notifications for failed tests

Now that our automated uptime checks are running let's make sure we're notified via Slack when our website is down.

In this example, we'll check if the test result contains a specific string using a filter. If the website is up, the result will include this string. If the website is down, it will not contain the string.

Adding a filter to our Zap

Add a new action
1. Search for and select the "Filter by Zapier" app
Configure the filter
1. Choose Field: Pick the field from the Globalping result that contains the raw result data (for example, "Results Probe Result Raw Body")
2. Choose Condition: "Contains"
3. Text or data: Enter the string to look for. I'll use "Monitor, debug and benchmark" from the Globalping website.

Note: If you're running more than one test, you need to click "Add Or rule group" for each one. For example, if you set the limit to three, you'll need three filter conditions. Repeat steps 1 and 2 for all rule groups, making sure to pick the correct result data for the "Text or data" field.

When you run the test, Zapier will tell you that the Zap would not have continued for this test data. This outcome is what we want, as we only want to proceed when the specified string cannot be found in the result (i.e., your website is down).

However, let's change the filter condition to "Does not contain" so that the filter allows the Zap to continue for testing purposes.

Remember to change it back to the original setting before you publish your Zap!

Adding Slack to send notifications

Add a new action
1. Search for and select the "Slack" app
2. Set "Action Event" as "Send Channel Message"
3. Connect your Slack account
Configure the Slack app
1. Channel: Select the Slack channel where you'd like to receive the notifications
2. Message text: Enter a message text. You can include data from the Globalping test results if you want.
Test
1. Run a test to send a message to your Slack channel

Note: You can add the link to the Zap in the Slack message. This can be useful when your website goes down, as you can quickly access the Zap to disable it (pause the uptime checks) until the issue is resolved.

Now, you'll receive notifications when your website or service is down, allowing you to react quickly and reduce disruptions.

Step 3 – Use AI to summarize test results

Finally, we'll use Zapier's new AI app to analyze the failure data and provide insights for troubleshooting, which will be emailed to you.

Why use AI?

The amount of data Globalping returns per HTTP test is quite a lot, especially when you run multiple tests. Looking through all this information to spot the bits you're interested in can be quite challenging. Also, when your service is down, you may not have the time to review the test results yourself. AI can help by analyzing the data, extracting relevant details, and summarizing the findings in a human-readable format, saving you time and effort.

Adding AI to summarize results

Add a new action
1. Search for and select the "AI by Zapier" app
2. Set "Action Event" as "Analyze and return data"

Configure and test:

Output field: Define the field under which to access the AI summary later. I'll name it "summary".
Prompt: Write a prompt that instructs the AI on what to do. Also, make sure to include the needed Globalping data to analyze! Here's an example:

Analyze the following Globalping test data and provide a summary 
highlighting the key findings, (potential) issues, trends, and other 
noteworthy information. Also, add some information about the probe 
Globalping used to run the test to add some geographical context. 
Finally, format the summary as HTML so it is easy to read and digest. 

Test Results: {{Results Probe 1 Result Raw Output}}
     
Probe information: 
City: {{Results Probe 1 City}}   
Network: {{Results Probe 1 Network}}    
ASN: {{Results Probe 1 Asn}}  
Resolvers: {{Results Probe 1 Resolvers}}

Run a test to see if you're happy with the AI's output, and fine-tune the prompt until you get the desired results (I’ll show you my result in a moment).

Sending AI summaries via email

Add a new action
1. Search for and select the "Email by Zapier" app
2. Set "Action Event" as "Send Outbound Email"
Configure
1. Set up the email basics like "from" and "to"
2. Body: Add the summary field from the AI step above

Test
1. Testing this action will send an email to the specified address containing the AI-generated summary. Here's the content of the email I received:

Subject: 🚨Website is down!🚨

Globalping Test Summary

Test Result Overview

Status: HTTP/1.1 200 OK
Date Tested: March 03, 2025
Response Time: 21 ms
Server Used: Cloudflare
Cache Status: Dynamic ### Key Findings
The test successfully returned a status code of 200, indicating the server is operational and reachable.
The response time of 21 ms is relatively fast, suggesting good performance for users in the tested region.
Content-Encoding used is Brotli (br), which is efficient for reducing data transfer size. ### Potential Issues* No immediate issues were identified based on the response code and time.
Consider the cache control settings that allow for revalidation and potential staleness; this may impact user experience if not managed properly. ### Probe Information* Probe Location: Shanghai, China
Network Provider: China Mobile Communications Group Co. Ltd.
ASN: 9808
DNS Resolvers: 223.5.5.5, 223.6.6.6 ### Conclusion The test results indicate a healthy server response and performance from the Shanghai probe, with low latency and a successful HTTP response. Continuous monitoring and proper cache management are recommended to maintain optimal performance.

Wrapping up

And that's it! You now have a simple uptime monitoring setup for your website, with email summaries providing insights into issues and performance in your inbox.

Let's recap what we've built:

We automated uptime tests using Globalping and Zapier's Webhook app
We set up Slack notifications for failed tests
We used AI to analyze Globalping's result data and write summaries, which we sent via email

Compared to paid uptime monitoring services like uptime.com or updown.io, this DIY approach can save you significant money, provided you already have a Zapier Pro subscription.

With the current setup, you're still far from Globalping's hourly limit (500 for registered users).

Let's say you run a measurement from one location every 3 minutes; this results in 20 tests per hour. If you run the same measurement from three locations, you'll have a total of 60 tests per hour. So, there's plenty of room for you to run additional tests or create a new Zap for different measurements, like performance checks.

Ready to take your network monitoring to the next level? Try the Globalping Zapier integration and see how it can help automate many of your network-related tasks!

How to get TLS from any location using Globalping

Dmitriy A. — Wed, 06 Mar 2024 15:55:47 +0000

Globalping is a platform that allows you to perform network measurement tests like ping, traceroute, and HTTP on probes worldwide. The HTTP test type is especially useful when you want to test API endpoints or check a website's response headers, for example. However, some Globalping users are unaware that they can also obtain information about the test target's TLS certificate, which requires a bit of digging into the response.

TLS (Transport Layer Security) is a protocol that ensures secure communication over the internet by encrypting data exchanged between two parties. It's an improvement over SSL (Secure Sockets Layer), and while you may still hear people talk about SSL, what they really mean is TLS.

In this article, we'll show you how to access TLS data using Globalping's web UI and CLI tool, so regardless of your technical ability, you can follow along. We'll also explore some use cases where looking into TLS information with Globalping comes in handy.

Accessing TLS information with Globalping

We'll now look into two methods of creating HTTP tests to get TLS certificate data. If you are unfamiliar with CLI tools or prefer working with a graphical interface, using the web UI is the right choice for you. If you like working in your terminal and even want to parse the data directly in there, check out the CLI tool explanation.

Using the Globalping Web UI to get TLS data

Follow these steps to run measurements on our website:

Visit our website and go to the top of the page to find the UI to run measurements.
Fill out the form with the following information:
1. Test Type: Choose "HTTP" as the test we want to run.
2. Target: Type in www.jsdelivr.com or your website's URL.
3. Location: Leave it as it is or, if you want, define a different location, such as a city, country, or region. You can learn more about defining locations on GitHub.
4. Limit: Set this to 1; it defines the number of probes we want to run our test.
5. Method (optional): Click on the gear icon to access the advanced settings. There, pick the "HEAD" method since we are not interested in getting the contents of our defined target.

Leave everything else as it is and click the "Run Test" button.
After you run the test, you can see the test result data below the map. The data should look similar to what you can see in the screenshot.

While you can see the timing data, including the time it took from establishing the TCP connection to establishing the TLS session (in the screenshot, it's 22ms), there's no information about the TLS certificate. That's because what you see here is just a section of the complete measurement response.

So, to view TLS data, we need to retrieve the complete measurement response:

Under the result data, there's a share link that you can use to share the result with others. The alphanumerical string at the end of the link (the value of the URL parameter measurement) is the identifier for your measurement. Copy it to your clipboard.
Paste the identifier to the end of this URL: https://api.globalping.io/v1/measurements/
1. For example: https://api.globalping.io/v1/measurements/zCEK4Pr37zzyajLH
Copy and paste the URL into your browser's address bar. This URL directly calls the Globalping API to fetch the measurement result for the provided identifier.
You now see a JSON object that contains the complete result, which we'll look into in the next section.

Using the Globalping CLI tool to get TLS data

To use the Globalping CLI tool to get TLS data, follow these steps:

Make sure you have the CLI tool installed and ready.
To replicate the example from the Web UI section above, type the following command into your terminal and execute it:
globalping http https://www.jsdelivr.com from world --limit 1
As a result, you will get the standard information for an HTTP HEAD request, but you won't see any TLS information.

What you see is only a section of the complete response – to get all the data, you need to append the option --json to your command:
globalping http https://www.jsdelivr.com from world --limit 1 --json
You should now see the entire measurement result as JSON data, which you can use for further processing. We will discuss how to do this in the next section.

Note:

You can also get the measurement identifier by running the command with the --share option. This will give you a link to share your result, and you can use the appended measurement identifier to request your measurement result directly from the API. We've explained how to do this in the section on the Web UI above.

Extracting TLS data from the response

First, let's tour the TLS data you can retrieve with Globalping. For this, we'll use the JSON from our measurement result.

Help:

If you're not sure how to get the JSON data in a readable format, you can use an online tool like JSON formatter. Just copy and paste your JSON code into the text field and press "Process."

You can then see the prettified JSON – scroll to the end of the JSON and find an object named tls containing the TLS certificate information.

Alright, let's take a look at the data!

You can find the tls information inside the result object of a test:


 json
"tls":{
       "authorized":true,
       "createdAt":"2024-01-19T19:08:46.000Z",
       "expiresAt":"2024-04-18T19:08:45.000Z",
       "issuer":{
          "C":"US",
          "O":"Let's Encrypt",
          "CN":"E1"
       },
       "subject":{
          "CN":"www.jsdelivr.com",
          "alt":"DNS:www.jsdelivr.com"
       }
    }

authorized: Indicates whether a trusted authority signed the certificate.
createdAt: The creation date and time of the certificate.
expiresAt: The expiration date and time of the certificate.
issuer: Information about the certificate issuer, such as Let's Encrypt. It includes the country (C), organization (O), and common name (CN).
subject: Information about the certificate's subject, such as your website. It includes the common name (CN) and any alternate names (alt).

Tip:

You can also find a timings object in the same result object. This contains details about the HTTP request times in milliseconds, including the time from establishing the TCP connection to establishing the TLS session (TLS handshake).



"timings":{

   "total":52,

   "download":1,

   "firstByte":18,

   "dns":2,

   "tls":22,

   "tcp":9

}

Extracting TLS data in your terminal

Here's a basic command that runs the Globalping HTTP command and extracts the tls information from the JSON result:

globalping http https\://jsdelivr.com from world --limit 1 --json --ci | jq -r '.results\[].result.tls | to\_entries\[] | "\\(.key): \\(.value)"' | sed 's/"//g' | awk -F ': ' '{ if (NF==1) next; else print $1 ": " $2 }'

We're using the sed and awk commands to bring the data into a nice format. Additionally, we're using the jq command-line JSON processor to work with the JSON data, so make sure you have it installed before running the command.

The output should look something like this:

Feel free to copy the command and adapt it to your needs!

If you want more flexibility, you can also use the Globalping API to create measurements, retrieve the JSON result, and process it in your code however you want.

Handy use cases for using Globalping to get TLS data

Now that we've explored how to obtain, view, and extract TLS data, let's explore some practical use cases of leveraging the Globalping probe network to request TLS data from various locations worldwide.

Monitoring globally distributed systems: By monitoring TLS data, you can make sure that TLS certificates are correctly installed, secure, and up-to-date, which helps maintain the security of your systems. And if you do this from different locations, you can ensure that monitoring continues without interruption, even if problems occur at one location.
Security research and analysis: Analyzing TLS certificates can provide useful insights into potential security vulnerabilities or threats. To identify and address security risks, you may want to examine TLS certificate data such as issuer information, the subject's alternative names, and expiration dates.
Compliance requirements: Many companies must perform security checks from different locations to meet regulatory standards or internal policies. Globalping can help your company meet these compliance requirements and maintain a secure online environment.
Performance optimization: To improve the performance of your websites and applications, it can help to evaluate the time it takes to complete the TLS handshake process from different locations. By checking the timings\ data provided in Globalping JSON results, you can detect any delay issues that may occur during the TLS handshake.

Conclusion

In this article, we've explained how to get TLS data using Globalping's HTTP test type and how to extract this information from the JSON output. Additionally, we've explored some use cases where requesting TLS data with Globalping can help with system monitoring, security research, compliance adherence, and performance optimization.

If you want to learn more about using Globalping effectively, visit our blog and check out our best practices on GitHub.

RIPE Atlas and Globalping: Choosing the Right Network Measurement Platform

Dmitriy A. — Thu, 22 Feb 2024 16:02:38 +0000

In today's world, where everything is interconnected, it's important to understand how our digital infrastructure, including the internet and our own smaller networks, performs. Whether you're a seasoned network expert or just starting out, having the right tools at your disposal can make a big difference.

In this article, we’ll take a closer look at two helpful tools: RIPE Atlas and Globalping. Both are network measurement platforms that allow you to evaluate the performance and reliability of networks using a globally distributed probe network.

We’ll also compare the two platforms and see in which use cases the newer Globalping platform can be a great RIPE Atlas alternative. By the end of the article, you may even want to use both platforms together to get the best insights!

Introducing the Platforms

To start, let's give you a brief introduction to the two tools:

Introducing Globalping

Founded by the jsDelivr team in 2021, Globalping is a platform that relies on an extensive probe network hosted in users' homes and offices worldwide. The platform aims to provide an excellent user experience, making it straightforward for users from all backgrounds to create their measurements effortlessly.

The platform is entirely open source, and all tools, including the API, are free to use. You can also support the project and its users by hosting one or more probes.

Globalping offers various official integrations and tools to ensure a seamless experience. For example, you can use the CLI tool to bring the platform's capabilities to your terminal. Or you can add the Slack app to your workspace, which enables your team to collaborate and troubleshoot effectively, making Globalping an interesting RIPE Atlas alternative.

Introducing RIPE Atlas

RIPE Atlas was founded by the RIPE Network Coordination Centre (NCC) in 2010, and it has since grown its network to consist of over 12000 probes to measure internet connectivity worldwide. All data collected by the platform is publicly available, which makes it popular with researchers and organizations interested in monitoring and learning about the state of the internet in real time.

By spending credits, you can create your own measurements and view the results in their dashboard, rendered over maps, or as raw data. You can earn credits in various ways, such as hosting a probe or purchasing credits directly, although that’s limited to bigger enterprises.

In addition, there are several tools available, including data parsers, CLI tools, and apps, which have been created by both the RIPE NCC and the community.

Comparing the Two Platforms

Below, you'll find a list of criteria along with some comments on how each platform handles and performs in those areas. Our goal is to emphasize the strengths of both platforms, as each one has its own features and benefits, catering to a wide range of users and use cases.

Probe Network

Globalping: Has a quickly and continuously growing probe network. Anyone can host a probe – all you need to do is run the probe's Docker container on an internet-connected machine.
RIPE Atlas: Offers an extensive probe network across the globe. If you want to host a probe, you need to apply for one first. If the network would benefit from your probe's location, you'll get a hardware probe sent to your address where you need to set it up.

Measurement Types

Globalping: All tests report their results back in real time, creating a feeling of local testing and allowing different kinds of new use cases. Supported test types are:
Ping, Traceroute, DNS, HTTP (including SSL), and MTR.
RIPE Atlas: The platform is focused more on scheduled measurements resulting in delays that may happen due to RIPE's complexity. Supported test types are:
Ping, Traceroute, DNS, HTTP, SSL, and NTP.

Measurements and Costs

Globalping: Enables you to create measurements for free, regardless of the tool you use, whether it is the API, CLI tool, or Slack app. However, some rate limits are in place to safeguard the API, which are usually sufficient for most users. But, if you need more, you can increase the limit by becoming a GitHub sponsor or earn free credits by hosting multiple probes at home, in the office, or on hosting providers.
RIPE Atlas: Allows you to create measurements, but it costs credits. You can obtain credits by hosting a probe, requesting credits as a researcher, receiving transfers from other users, or buying credits by becoming a corporate sponsor. However, becoming a sponsor may be too pricey for individuals.

Internet Health Monitoring

Globalping: Doesn't offer public internet health monitoring capabilities at the moment. Instead, it focuses on providing measurement creation capabilities to users.
RIPE Atlas: Offers public access to all measurements. You can analyze internet health data by viewing maps and graphs, which provide detailed insights.

Custom Monitoring Capabilities

Globalping: You can leverage the API to develop your own monitoring solution, which many companies already do. The Globalping team is also working on building a custom and scheduled monitoring platform. This platform will use the probe network to provide real-time and historical data on the performance and quality of any internet endpoint.
RIPE Atlas: You can specify intervals and timeframes for running measurements and then analyze the results using maps and graphs that the platform generates and displays on its website.

Use Cases

Globalping: Designed to be used by users with various backgrounds and networking skills. It allows you to create network measurements effortlessly and for free, making it a great RIPE Atlas alternative when you want to learn more about networking or investigate your own networks in-depth. Overall, Globalping is suitable for both newcomers and network experts.
RIPE Atlas: Tailored for researchers, academics, and anyone who needs access to aggregated internet connectivity data. The platform also allows you to investigate the impact of global or local incidents on internet health, such as natural catastrophes.

Commercial Use

Globalping: Doesn't differentiate between personal and commercial use, and you don't need an account or authentication for basic tests.
RIPE Atlas: If you plan to use the RIPE Atlas platform to provide paid services or products, there are some rules you need to follow. These rules include, for example, displaying the platform's logo and description. The platform's credit-based usage system also applies here.

Data Usage

Globalping: Measurement results are stored for a limited time; only users with the measurement link can view them. Also, probe owners can see the tests their probe ran.
RIPE Atlas: All measurements conducted on the platform are publicly accessible.

Tools and Integrations

Globalping: Provides user-friendly tools and integrations for custom development, Slack, and GitHub. The Globalping team officially maintains all tools, ensuring ongoing development, support, and a consistent and modern UX.
RIPE Atlas: You can find many open-source tools, including CLI tools and visualization libraries, on the website and on GitHub. Some of these tools were created during hackathons and may not be regularly maintained, so keep this in mind when searching for tools.

Getting Involved

Globalping: Invites you to host one or more probes, become a GitHub sponsor, or contribute to the platform on GitHub. The team welcomes any feedback and feature requests, which are essential for the platform's continuous improvement and growth.
RIPE Atlas: Encourages you to host a probe or an anchor, sponsor the project by buying credits, become an ambassador, or contribute to the open-source tools.

Is Globalping a RIPE Atlas alternative?

Our comparison between Globalping and RIPE Atlas showed that both platforms have unique benefits:

With its extensive public internet health data, RIPE Atlas is great for researchers and network experts who require detailed analysis. On the other hand, Globalping's modern approach, user-friendly UX, and free measurements make it compelling for a wide range of users. This makes it a great alternative to RIPE Atlas for individuals as well as companies ranging from startups to enterprises.

However, each platform has its features and strengths, so we think it's worth using them together. By leveraging Globalping to run real-time measurements in a comfortable way and RIPE Atlas to obtain aggregated data, you can get a more in-depth view of the state of the internet and your own networks.

If you're new to Globalping or looking for a straightforward way to get started with networking, we invite you to visit our website and create your first measurements!

New Globalping feature: Eyeball and data center network tags

Dmitriy A. — Thu, 09 Nov 2023 13:48:54 +0000

Today, we're happy to announce the release of a new Globalping feature that has been highly requested by our community: the ability to run network measurement commands from probes within eyeball or data center networks! You can combine these new tags with any existing Globalping feature and use them in any of our integrations, such as the CLI tool or Slack app.

In this blog post, we'll introduce you to these new tags and explore different ways you can use them.

Background: Understanding eyeball and data center network tags

We've assigned new system tags to each probe in the Globalping network that identify it as part of an eyeball network (your regular ISP) or data center network so you can run your test commands from one or the other. Let's talk more about these networks and the assigned tags:

Eyeball networks

Eyeball network probes are typically hosted in real-world environments like peoples’ homes and offices. Many of our users asked for a way to assess network performance from the perspective of everyday internet users and their regular IPSs, and that's exactly what the eyeball tag enables you to do.

For example, imagine you're a streaming platform looking to enhance streaming quality for your users or a Content Delivery Network (CDN) provider aiming to reduce latency and optimize content delivery, especially from ISPs. The eyeball tag is what helps in both cases.

Data center networks

In addition to the eyeball tag, we've introduced the data center tag for probes within data centers. These probes are especially useful if you want to learn more about a cloud provider's performance, routing, and data center-to-data center communications.

For example, using the data center tag can help you determine which hosting company is the best origin for your CDN or identify the optimal AWS region. It can also be useful when you want to optimize the overall performance of your network without a specific bias towards regular ISPs.

In action: Using our new eyeball and data center tags

Naturally, you can use the new tags across any of our integrations, whether through the web-based tool, CLI tool, Slack app, or GitHub bot.

Note that we'll be using the CLI tool in our upcoming examples – but feel free to follow along with your favorite integration!

The two new tags at your disposal for writing measurement requests are:

eyeball

datacenter

These tags are combinable with all of Globalping's existing features, and they can be paired with location types in various ways, which we'll explore in a moment.

The important point to remember is to define the tag together with the location from which you want to run a measurement request.

The basic structure of a command looks like this:

globalping [command] [target] --from [location & tag combos] [options]

Let's check out some examples!

Combining with the `world\` location

The world location is the default setting used by our API, but you can also specifically define it in your requests. This comes in handy when you want to run tests from random global locations while keeping a balanced probe count across continents.

So, for example, to request traceroute measurements from 10 probes around the globe, all of which are from eyeball network probes, run the following command:

globalping traceroute jsdelivr.com --from world+eyeball --limit 10

Since world is the default location used if you don’t specify a specific location, you can also simplify the above command and use the eyeball tag by itself:

globalping traceroute jsdelivr.com --from eyeball --limit 10

Combining with a specific location

Like the previous example, you can also set a specific location instead of letting the API select a random one.

Remember, valid locations include countries, continents, cities, US states, regions (Western Europe), ASNs, ISP names, and cloud region names (us-east-2).

For example, let's say you want to run a ping test from Berlin and limit the probe selection to eyeball network probes; use the following command:

globalping ping jsdelivr.com --from Berlin+eyeball --limit 1

Here's what the result could look like:

Stacking filters

In the examples above, we've already utilized the "+" sign to combine a location and tag. You can also use the "+" sign to stack various locations and tags to create filters to refine your queries.

For example, to run two ping tests from eyeball network probes in North America within the ASN137409, run:

globalping ping jsdelivr.com --from "North America+eyeball+as137409" --limit 2

The result looks something like this:

Stacking filters and combining locations

You may have already executed a measurement request from multiple locations by listing them with a comma like this:

globalping ping jsdelivr --from "Berlin,USA,South Africa" --limit 3

This command results in three ping tests: one from Berlin, one from the USA, and another from South Africa.

Combining locations and defining filters using the "+" sign enables you to create even more fine-tuned requests. For example, to perform ping tests from an eyeball network probe in Berlin and a data center network in New York, use the following command:

globalping ping jsdelivr.com --from "Berlin+eyeball,New York+datacenter" --limit 2

The result looks something like this:

Conclusion

Our new system tags allow you to run measurement commands from data center and eyeball networks, opening up valuable perspectives for network analysis. Whether you want to improve your users' experience or delve into infrastructure details, these tags can help you get the needed insights.

Visit us on GitHub to learn more about Globalping features and best practices, and leave us your feedback so we can make Globalping a better platform for everyone!

Happy testing!

Top 10 Slack Apps for DevOps Teams

Dmitriy A. — Thu, 12 Oct 2023 14:17:51 +0000

Slack has become an essential digital communication tool for many teams that brings everyone together in one place, supporting productive collaboration. To get even more out of Slack, many workspaces use Slack apps, and especially for DevOps teams, choosing the right app can be tricky due to the wide selection.

In this blog post, we'll introduce you to our ten favorite Slack apps that make your everyday DevOps life much more convenient!

GitHub – Get updates on GitHub activity

If your team uses GitHub, the dedicated GitHub Slack app is an absolute must for your workspace as it helps you stay in the loop about GitHub activity and opens the door for discussions with your team.

With this app, you can subscribe to your team's repositories to ensure you and your team receive notifications about new commits, pull requests, code reviews, or issues.

/github subscribe owner/repo

You can also take action directly in Slack using the following format:

/github [action] [resource]

This means you can perform everyday GitHub actions, such as closing or reopening issues and pull requests or even creating new issues – all without leaving Slack and constantly switching between tools!

CircleCI – get CI/CD notifications

If your team uses CircleCI for continuous integration and deployment, the CircleCI Slack app can be a great addition to your workspace.

Thanks to this simple app, you no longer need to manually check the status of your CircleCI builds. Instead, the Slack app provides instant updates on build and deployment status so you know when a CircleCI build is complete. In the meantime, you can focus on other, more pressing matters without feeling like you've forgotten something.

Not a CircleCI user? No problem! Check out similar apps from other providers, such as Jenkins CI or Travis CI.

FireHydrant – Manage incidents

FireHydrant is an incident management platform you can integrate into your Slack workspace. The tool helps improve your DevOps team's incident response by keeping you informed from the moment an alert is raised until the issue is resolved – without leaving the familiar environment of Slack.

When you kick off an incident in Slack, FireHydrant gathers all the essential information from your defined service catalog and starts running your FireHydrant Runbooks. These Runbooks automate tasks like ticket creation and customer support notifications, reducing the time you spend on manual work.

Moreover, it also tracks incident timelines, manages communication updates across various channels, and integrates with popular tools like PagerDuty, Zoom, or Jira.

CTO.ai – Slack-first serverless DevOps

Ever heard of SlackOps? Meet CTO.ai, a platform that lets your team streamline DevOps workflows and improve collaboration, whether you're working from the office or on the go, as long as you have Slack with you.

First, you need to write your DevOps workflows using the CLI tool and then access them from within Slack, resulting in instant ChatOps compatibility.

For example, to start one of your DevOps workflows from Slack, run:

/ops run [Workflow_name]

Ultimately, your team can run workflows from anywhere while getting real-time insights into what's happening. The platform aims to simplify developers' lives and streamline product releases, cloud deployment, and employee onboarding.

json.dev – JSON formatting simplified

Sending code snippets or data to your fellow DevOps engineers in Slack is something you probably do almost every day. However, formatting it for readability can be a bit of a hassle when it's JSON. Often, you'll need to prettify the JSON in another tool before you can paste it back into Slack and send it.

This is where json.dev comes in, making your life easier by removing the pain of copying, pasting, and switching between tools just to send pretty JSON. Install the json.dev Slack app and use it right away to send your colleagues JSON data they can actually read.

Here's how you can prettify JSON:

/json fmt {"example": [{"foo": 1, "bar": 2},{"foo": 3, "bar": 4}]}

And voilà! The Slack app transforms it into beatufiul JSON:

Finally, you can also minify the JSON again using the minify\ command.

Buddy – Easy CI/CD

Buddy is a CI/CD and automation platform that simplifies the process of building, testing, and deploying code from GitHub, Bitbucket, and GitLab. With Buddy, teams can quickly create custom deployment pipelines with a visualized user interface, making it a great tool for any developers or engineers who are not (yet) DevOps experts.

Buddy's Slack app keeps your DevOps team in the loop by providing real-time updates, including pipeline activities like builds, deployments, and any issues along the way. As a result, your team can discuss results and share insights in your shared Slack channel, improving collaboration.

Globalping – Global network testing

Globalping is a network testing platform that allows anyone to run measurement requests such as traceroute, mtr, dig, and curl from virtually anywhere in the world to test and troubleshoot networks.

With the Globalping Slack app, you can integrate the platform's features with Slack to help you collaborate with your team in critical situations like network outages. Ultimately, anyone in your workspace can run measurement requests directly from Slack, regardless of their technical expertise, making it a real benefit for cross-team collaboration.

Writing Globalping commands is straightforward – in its most basic form, you just need to define the network test command and a location from which to run it. In this example, we run a traceroute to a website from London:

/globalping traceroute dev.to from London

You can specify multiple locations by separating them with a comma or combining them with a "+" sign. For instance, "Amsterdam, Canada, us-east-2" would initiate commands using a random Globalping probe at each defined place. On the other hand, "Amsterdam+eyeball" would run your measurement request from a random eyeball network in Amsterdam. In essence, you can define various location types, and Globalping will try to select the most suitable probes for you.

Azure Pipelines – Monitor pipeline activity

Azure is likely your go-to for DevOps if your company relies on Microsoft products. And with the Azure Pipelines App for Slack, monitoring your Azure pipeline activity becomes super convenient. It lets you set up and manage subscriptions for various events directly from Slack, including completed builds, releases, and pending approvals. You'll also receive notifications for these events in your Slack channels.

It's also likely that your team uses other Azure products – the good news is that the Slack App Directory offers various Azure apps, including Azure Boards and Repos. This way, you can bring even more productivity- and collaboration-enhancing features and insights to your Slack workspace.

AWS chatbot – Monitor and interact with AWS

The interactive AWS chatbot Slack app is a valuable tool for monitoring and interacting with your AWS resources directly through your Slack channels. The app sends alerts to your workspace, enabling your team to quickly respond to events like a CloudWatch alarm. Additionally, you can access log files with a simple click, so you don't have to switch between different tools.

Finally, you can even execute AWS CLI commands within Slack. This means that anyone accustomed to working with the terminal can seamlessly do so right from Slack, keeping everything in one convenient place without losing the benefits of the CLI.

Truffle – Your FAQ support

You most likely share a Slack workspace with the entire company or your product team, which often means your DevOps teams' expertise is in high demand. However, you'll often get the same repetitive questions, and answering them takes away from your time and focus. So, that's where Truffle comes in, a Slack app that answers recurring questions by building a wiki-like knowledge base from your past conversations!

Once you add Truffle to your channel, it starts collecting knowledge. When someone asks a question in a Truffle channel, Truffle answers it for you (assuming the information is available, of course). This allows you and your team to spend more time on new and more complex questions while ensuring everyone gets the answers they need to do their work.

Conclusion

Have you already integrated some of the Slack apps we've featured? Either way, we hope you've discovered a Slack app or two worth trying, especially if you're already using the tool behind it anyway!

Like what you've read? Check out our other blog post about our top 10 favorite CLI tools for DevOps teams.

Supercharge Your GitOps Workflows with the Globalping GitHub Bot

Dmitriy A. — Tue, 19 Sep 2023 13:00:18 +0000

If you're anything like us, you're always on the lookout for ways to streamline and improve your workflows, especially when dealing with essential yet sometimes complex tools like GitHub. That's why we created the Globalping GitHub bot: it helps to collaborate on issues and supports teams' GitOps processes.

Globalping is a network testing platform that empowers you to run commands like ping and traceroute from almost any location worldwide. You can use our platform through various integrations, such as our CLI tool, with the GitHub bot being the latest addition.

In this article, we'll introduce you to the Globalping GitHub bot, show you how to use it, and explore some typical use cases where it can make your GitHub experience more productive and enjoyable.

Exploring the Globalping GitHub bot

Are you new to the entire GitHub bot topic? Then, let's bring you up to speed before moving on.

GitHub bots (or GitHub Apps) are essentially automated helpers designed to improve how you work with the platform or extend its functionality. Anyone can create a bot for their own needs or to share with others on GitHub. Some use cases range from automating routine tasks like commenting to performing specific actions when someone creates a new pull request. Bots are also often used to integrate GitHub with other platforms, such as CircleCI, Azure, SonarCloud, and many others.

Now, what can the Globalping GitHub bot do?

In essence, our Globalping GitHub bot can do everything our CLI tool can – it can run network measurement commands from virtually anywhere while maintaining the same command structure. This ensures that using Globalping remains simple and consistent, regardless of which integration you are using. Also, there's no need to install anything to use our bot. You can trigger it in any public GitHub issue by commenting @globalping followed by the network command you want to run – but we'll go into more detail about the hows in a moment.

Note: If you want to learn more about the Globalping platform and how it works, check out our introductory blog post.

Using the Globalping GitHub bot

Let's roll up our sleeves and see the Globalping bot in action. All you need to get started is a GitHub account and a publicly available issue (this is important!) where you want to trigger the bot.

Globalping has a handy --help option that is a good starting point for exploration. So, let's have our first interaction with the bot to get help:

Open an existing publicly available issue or create a new one.
Activate the bot by commenting "@globalping --help", i.e., write the command in the comment text box and submit it. Be sure to mention the bot with the "@" sign, just as you would to reference a GitHub user.
Give the bot a moment to process your request and work its magic.
Voilà – you should see the bot's comment, including information about how to use it.

You can get more information about specific measurement commands by writing a command type with the --help flag in this format:

@globalping ping --help

In this example, the bot comment explains how to use the ping command and what flags (options) are available.

It also describes the command structure, which is the same for all available commands:

@globalping [command type] [target] from [location] [flags]

Now that we've learned the basics, we can create more interesting network measurement requests!

Example: Ping a target from Berlin using two probes.

Let's put our newly acquired knowledge into practice. In this example, we want to ping a target from Berlin using two probes (meaning we'll also get two ping results). Here's how you can achieve this by creating a simple command within your GitHub issue:

@globalping ping jsdelivr.com from Berlin --limit 2

After a short moment, you should see the comment, including the result that looks something like this:

By default, Globalping sets the probe limit to 1, meaning it selects a single active probe for the measurement. However, in this example, we explicitly request two probes to perform the ping command from Berlin using the option --limit.

Example: Traceroute a target from an AWS probe in Montreal using UDP

Suppose you're curious about your data's network path as it travels from an AWS probe in Montreal to a specific target using the UDP protocol. To get this information, here's the traceroute command to comment on your GitHub issue:

@globalping traceroute jsdelivr.com from aws+montreal --protocol udp

The result will look something like this:

In this example, we've used the + sign to combine two location types and fine-tune our request. The Globalping API, responsible for selecting the fitting probes to run commands on, does its best to interpret the location you provide, so feel free to experiment! You can specify countries, continents, cities, US states, regions, ASNs, ISP names, and cloud region names.

Additionally, we've used the --protocol option, which is unavailable for other commands like ping. While all commands share certain options, such as location (--from) and the number of probes (--limit), some support unique options. For instance, you can define the protocol (--protocol) for traceroute or specify the number of ICMP packets (--packets) to send with ping.\
Check all available options with the --help option!

Leveraging network troubleshooting in Github issues

Now that we've got the hang of using the Globalping GitHub bot let's explore some use cases and the benefits for your GitOps workflows and collaboration on GitHub.

View network issues from a user perspective.

Thanks to our global network of probes, you can assess network performance and issues from almost any location. Whether your users are in major cities or rural areas, you can directly replicate their experiences and troubleshoot location-specific problems in the relevant GitHub issue.

Improve collaboration.

By letting anyone effortlessly integrate network data into public GitHub issues, our Globalping bot can help streamline GitOps workflows and make collaboration more efficient. No more tedious copying and pasting and switching between different tools – with our bot, you can run network tests directly in GitHub and ensure that essential data is immediately available where you need it.

Get issues resolved faster.

Having commands like ping, traceroute, mtr, dig, and curl at your fingertips to collect information on network latency, routing paths, DNS resolution, and more can help you solve problems hinging on network data faster. With the help of the Globalping bot, you can add more relevant information to a GitHub issue, providing actionable insights and potentially making it easier to understand and solve the problem.

Conclusion

Whether you want to fine-tune your network configurations, solve connectivity issues, or get insights into your network, the Globalping GitHub bot is here to help. Just mention "@globalping" alongside the respective command within a public GitHub issue, and watch the bot respond with results – no installations required!

Happy testing!

Top 10 CLI Tools for DevOps Teams

Dmitriy A. — Mon, 14 Aug 2023 15:34:16 +0000

For many DevOps teams, CLI tools have become indispensable helpers to automate tasks, manage infrastructure, and collaborate like a well-oiled machine. In this blog post, we'll share our top 10 CLI tools for DevOps teams that you'll enjoy integrating into your workflows!

Dive – Explore Docker images

Whether you work with Docker regularly or even create your own Docker containers, Dive is a great tool for streamlining image sizes, potentially helping you save storage costs and speed up deployments.

With the Dive CLI tool, you can dive into the layers of an image, see their size and content, and potentially uncover wasted space. For example, it lets you view the files and directories in each layer to find those that are unnecessarily bloating the image.

This enables you to take the necessary steps to reduce the image size by, for example, updating your .dockerignore file to omit the identified unnecessary resources.

HTTPie CLI – Test and debug APIs

HTTPie CLI is something like a modern alternative to the curl command, allowing you to interact with and test APIs, HTTP servers, and web services. Its developers have designed it to be powerful yet easy to use, thanks to its intuitive syntax and color-coded terminal output for better clarity.

The tool has numerous functions that allow you to perform a wide range of HTTP requests.

For example, a command to make a PUT request to an API endpoint with HTTP header data and some JSON data might look like this:

http PUT myapi.com/enpoint X-API-Token:123 username=pete1

AWS CLI - Manage AWS Services

The AWS CLI is a must-have tool if your team relies on Amazon Web Services. It lets you effortlessly interact with AWS services, orchestrate resource management, and automate tasks from the comfort of your terminal. Once you get used to the tool, you'll notice how convenient and quick it is to fit into your processes – especially compared to going through AWS's web-based user interface.

If you don't use AWS, you can usually find CLI tools for other major cloud infrastructure services, such as Azure CLI or gcloud CLI.

K9s – Manage Kubernetes Clusters

K9s is an open-source, terminal-based UI for interacting with your Kubernetes clusters, making navigating, observing, and managing your apps easier. If you use Kubectl but wish it was easier and faster to use, K9s might be just what you're looking for!

K9s visual approach makes viewing and managing pods, deployments, and services more straightforward. If you like to customize it, K9s' skins let you define your preferred look and feel. Additionally, you can add more features by creating plugins or choosing from plugins provided by the community.

Here's an example of K9s' pod overview:

Updatecli – Create custom update strategies

Updatecli is a useful tool for fine-tuning update strategies in DevOps. As you've probably experienced, manual updates often result in outdated specs because figuring out what can be updated is tricky.

Updatecli lets you define custom strategies so that each application "run" detects whether a value needs to be updated and then applies the changes according to the strategy. We particularly like Updatecli's plugin-based approach to adapting to different workflows, which keeps you flexible and independent of underlying dependencies.

JQ and YQ – JSON and YAML parsing and processing

JQ and YQ are handy CLI tools for anyone working with JSON or YAML in their shell scripts and terminal.

With JQ you can cut, filter, map, and transform JSON like with the sed\, awk\, or grep\ commands. YQ is more or less the same but is tailored to process YAML. Using these two tools, you can streamline data-driven tasks like testing API responses, managing configuration files, or handling Kubernetes manifests.

While JQ and YQ are not identical in use, they share many similarities. Here is a simple example of how to read a value from a JSON and a YAML file:



jq .name file.json

yq .name file.yaml

Terragrunt – Amplify terraform capabilities

If your team works with Terraform, you should definitely try Terragrunt (and obviously, its CLI tool!). It's an Infrastructure as Code (IaC) tool that acts as a wrapper for Terraform and simplifies dealing with multiple Terraform modules in different environments.

Other benefits of Terragrunt include modular code organization, common standards, and efficient versioning with Git that improve collaboration. It also simplifies state file management and managing states across multiple environments.

Globalping - troubleshoot and test networks globally

Globalping is a global network testing tool with an extensive probe network that allows you to make measurement requests like ping, traceroute, mtr, dig, or curl from almost anywhere in the world.

Using the Globalping CLI tool, you can quickly and easily test and troubleshoot APIs, DSN resolution, or your servers. For example, it allows you to look at network issues from the user's perspective by running commands from their location without actually having physical access.

When defining a location from which to run a command, you can simply enter something that makes sense to you, and the tool will do its best to select the appropriate probes. Valid location inputs include countries, continents, cities, US states, regions (Western Europe), ASNs, ISP names, and cloud region names (us-east-2).

Here’s an example where we used the Globalping CLI to ping a website from two probes in Athens and South America:

fzf – Command-line fuzzy finder

fzf is a fuzzy finder for the command line that is a great help in handling and navigating through data lists. It offers an intuitive user interface that allows you to quickly search, select and filter through various items, whether they're files, directories, command histories, or other text-based inputs. In addition, fzf has a real-time search function, a preview of file contents, and an auto-complete feature that minimizes the need for manual typing.
Once you get used to fzf to increase productivity and reduce errors, you won't want to return to a life without it!

urfave/cli – Build custom CLI tools

When it comes to finding the right CLI tools for a task, it often turns out that you need something tailored to your specific challenge or use case. That's when urfave/cli comes in handy, a Go package that provides a framework for creating your own Go command-line applications.

Its developers have designed it to be easy to understand and use and provide thorough documentation to help you get started and beyond.

So even if you don't find the perfect CLI tool in this list, you can leverage urfave/cli to create it yourself and share it with your team.

Conclusion

We hope you found one or two CLI tools in our list that you would like to try out to improve your DevOps team efficiency, collaboration, and infrastructure management.

Like what you've read? Check out our other blog posts for more DevOps and network testing insights.

Become Part of the Globalping Community: How to Run a Virtual Probe

Dmitriy A. — Mon, 12 Jun 2023 11:23:22 +0000

Globalping is a network testing platform that relies on a globally distributed network of probes hosted by our community to allow anyone to run network commands from anywhere.

This guide explores why Globalping improves with network size and how you can contribute by running your own virtual probe. If you are familiar with the Globalping platform and interested in making the Internet faster for everyone, this article is for you.

Why Globalping thrives on community contribution

The probe network and the Globalping API, which handles measurement requests between users and probes, form the platform's backbone. With them, anybody can run network commands like ping or traceroute from any corner of the world.

Today, we already have hundreds of active probes around the globe, mainly running inside Docker containers in the homes, offices, and cloud servers of individuals and partner companies.

What do the probes do?

The function of these probes is limited and simple: they receive measurement requests from the Globalping API, execute the requested commands, return the results to the API, and await the next event.

So how do more probes make the platform better?

Run commands from anywhere. With a large and dense global probe network, you can run measurements from any location in the world. With this, we hope to make testing, monitoring, and troubleshooting networks more accessible and easier for network experts and novices alike.
Improve web performance. For example, website owners can test their website or API load times from different regions to optimize their setup or select a better CDN or cloud provider that offers a more reliable and faster global infrastructure.
Increase platform availability and reliability. Not all probes can be online and operational 24/7, and there may be periods of high demand in specific areas. With a big probe network, you can count on getting reliable and consistent results, making Globalping ideal for uptime monitoring and SLA validation.
Enhance data quality. With a large network of probes, anyone can collect more extensive and accurate data globally or in underserved regions, leading to more valuable insights.

How to set up your own virtual Globalping probe

In this section, we'll set up a Globalping probe and address frequently asked questions about requirements, limitations, and security considerations.

Where can I run my probe?

You can run a Globalping probe on any machine that can run a Docker container, supporting x86 and ARM architectures. This could be an unused PC in your office, a Linux server hosted with a cloud provider or even a Raspberry Pi lying around at home.

And thanks to Docker, you don't have to do anything other than create and launch the container by following our instructions (we'll get to that in a moment).

What are the requirements and limitations of running a probe?

Our most important requirement is running the probe with a stable internet connection. So when it's online, there should be no packet loss, frequent disconnects, or other regular disruptions that could inaccurately affect the measurement results.

While 24/7 operation is ideal, it's not mandatory – we welcome everyone interested in running a probe, even part-time.

As for limitations, we allow only one probe per IP address and block probes from IP addresses associated with anonymous proxies, Tor, and VPN services or IP addresses that we can't resolve to a physical location.

But at the same time, we don’t require a unique public IP address. Your device can be behind a NAT, and the probe will work correctly since it doesn’t listen on any ports.

How to set up a probe with Docker

To create and run the Globalping probe container, execute the following Docker command in your terminal:

docker run -d --log-driver local --network host --restart=always --name globalping-probe ghcr.io/jsdelivr/globalping-probe

And that's it! Here you can see a probe running in Docker Desktop:

Do I need to update my probe?

Docker automatically fetches the latest Globalping probe version from our GitHub repository, which doesn’t update the container, only the code it’s running.

Therefore, we recommend you update the container regularly, but it's completely optional, and all you have to do is run these commands:

docker pull ghcr.io/jsdelivr/globalping-probe

docker stop globalping-probe

docker rm globalping-probe

docker run -d --log-driver local --network host --restart=always --name globalping-probe ghcr.io/jsdelivr/globalping-probe

Can I adjust the number of tests?

The number of tests your probe can process depends on the number of CPU cores available and the average CPU usage over the last few minutes. By default, our probes efficiently use available resources, so we recommend you leave it as it is.

However, you can control resource usage if you want. To do so, add the option --cpuset-cpus="0-2" to the docker run command and set the number of CPUs within the quotes.

Is Globalping secure?

Naturally, we don't want anybody to feel uncertain about running a probe or using Globalping for potentially malicious intents. So here are the most important measures we have in place:

Probes don’t open ports on your device or accept any incoming connections. They only establish a single outbound connection to the Globalping API.
Our API is rate-limited to prevent users from abusing the Globalping network. (We limit the number of API requests within a certain time frame).
Users can't send measurement requests to private IP addresses.
We actively block domains and IP addresses associated with malware or similar harmful content. For this, we use regularly updated databases of domains and IP addresses.

Can I run more than one probe?

If you can host probes in multiple locations and IP addresses, then yes, by all means! We are happy to list anyone who can host at least six probes as donors on GitHub and our website.

Join the Globalping community

The Globalping platform thrives on the contribution of its community, which powers the extensive probe network. With your invaluable support, we can continuously enhance the platform and provide improved, reliable results to all users free of charge.

Whether you are eager to run a probe or have questions, feedback, or other contributions, we invite you to join us on GitHub. We're happy to have you!

As an additional opportunity, we offer our GitHub Sponsors to become part of the network by providing a plug-and-play hardware probe.

Globalping Guide: How to Run a Ping Command From Anywhere

Dmitriy A. — Thu, 01 Jun 2023 14:22:52 +0000

Running ping commands from specific locations around the globe can be crucial for troubleshooting network issues or testing the performance of your globally-distributed servers.
But how can you do that?

While you may have the option to SSH into a remote server or use a VPN, these methods may not always be accessible or efficient. What if you want to ping from locations beyond your reach or run multiple pings simultaneously to save time?

That's where Globalping comes in. Globalping is an open-source network testing platform that allows you to run ping commands from (almost) anywhere in the world for free. So whether you're tech-savvy or a curious beginner, we'll show how to send ping requests from various locations using the Globalping platform in this guide.

What is Globalping?

Globalping is a community-powered network testing platform that empowers anyone to run networking commands, including ping, traceroute, dig, curl, and mtr, from anywhere across the globe.

To do that, Globalping relies on a network of hundreds (and counting) of probes hosted by individuals from our community in their homes, offices, and servers they control. Alongside the probe network, the Globalping platform provides an API that handles users' measurement requests. It runs every aspect, from taking requests and selecting appropriate probes to issuing the execution of commands and collecting the results, ensuring quick delivery to the requesting user.

How to run a ping command from anywhere using Globalping

We want Globalping to cater to users with different needs and technical expertise. That's why we're building several integrations that make using the platform a breeze:

Globalping CLI tool: If you like working with your computer's terminal and are familiar with running network commands, the CLI tool may be a great choice. We support all major Linux distributions, macOS, and Windows – you can find an installation guide on GitHub.
Globalping Slack app: With the Slack app, you can extend Globalping's functionality to your entire team, which can help foster collaboration during critical moments like outages.
Online tests: If you prefer a more straightforward approach without any installation, try the web tool on our website.

Now let's see these integrations in action!

Use the web tool for quick results

The web tool is your go-to option if you prefer a user-friendly interface or want to execute a ping command swiftly from any device.
To access the web tool, visit the Globalping website, where you'll find a form accompanied by a map.

Here’s an overview of the available form fields:

Test type: Select the network command you want to execute
Target: Enter the hostname or IP address of the target
Location: Specify one or more locations from where you want the API to select the probes. You can define multiple locations by separating them with a comma or combine filters with the "+" sign. The field accepts different location types such as ISP names, ASNs, US states, and regions such as Western Europe.
Limit: Determine the number of probes to run the command from
Settings: Customize other options depending on the selected test type. For ping commands, you can adjust the number of packets to send.
Map: Display the measurement results on the map below.

Let's send our first ping command via this form!

Example scenario: Run the ping command to jsdelivr.com from 10 random locations in Europe.

Fill in the form like so:

set the test type to "ping"
enter "jsdelivr.com" in the target field
specify "Europe" as the location
leave the limit set to 10
click on "Run test"

And voilá, you should see results in a few seconds.

If you've activated the Map switch, you can view the locations on the map where the API issued the ping command. These location points are color-coded based on the ping's rounded average round trip time (RTT). You can also click on the points for more details.

Below the map is a list of ping results for the ten probes. The first line displays the location, Autonomous System Number (ASN), rounded average RTT, and the packet loss percentage of the ping. The raw ping results are listed below.

Lastly, at the bottom of the list, you can find a link to share your measurement results with others.

Use the CLI tool or Slack app for more customization

The Globalping CLI tool and Slack app offer greater customization options than the web tools. Also, if you need to run network commands regularly, installing a Globalping integration on your machine can be more convenient than navigating to the web tool to run a command.

In the following examples, we'll focus on using the Globalping CLI tool for running ping commands. However, if you prefer, you can follow along using the Slack app, as sending measurement requests and reading responses are nearly identical.

Ping from anywhere using the Globalping CLI tool

Once you've successfully installed the CLI tool on your system, it's ready for use. First, you may want to familiarize yourself with the Globalping ping command by running help:

$ globalping ping --help

This command provides a summary of the ping command, example usage, and a list of available flags that let you customize your measurement requests. If you look at the examples, you can see that a Globalping ping command follows this structure:

$ globalping [command type] [target] from [location] [flags]

Let's write a simple measurement request using this structure.

Example scenario: Run the ping command to jsdelivr.com from Vienna and Berlin.

CLI command:

$ globalping ping jsdelivr.com --from Vienna,Berlin

If not defined otherwise, Globalping sets the limit of probes to 1. So when executing this measurement request, the Globalping API randomly selects one online probe from Vienna or Berlin. If we had limited the number to 2, the API would have selected one probe in Berlin and one in Vienna. So, in our example, the API chose Vienna:

Next, let's look at a more advanced example using some of the available flags.

Example scenario: Run the ping command to jsdelivr.com from 10 random locations within AS3209 and Greece and retrieve the results in JSON format.

CLI command:

$ globalping ping jsdelivr.com --from 3209,Greece --limit 10 --json

This returns the ping measurement results for ten probes as JSON, including the raw ping results in result.rawOutput and other valuable data. Explore our API reference if you're curious about the JSON response object and its contents.

Advanced tips

Finally, we want to provide you with some advanced tips and ideas that can help you get the most out of Globalping:

Experiment with locations: Globalping allows you to specify various types of locations, and it will do its best to understand and select suitable probes. You can input countries (Greece), continents (Asia), cities (Warsaw), US states (Idaho), regions (South America), ASNs (3209 for Vodafone Germany), and even cloud region names (us-east-2).
Use available flags: The CLI tool and Slack app offer flags that enable you to customize the results to suit your needs. We recommend you get to know all the options to avoid missing out on potential features that could simplify your workflow.
Automate commands: For example, save time by running ping commands automatically with a bash script. Or, if a less tech-savvy team member wants to run a ping at a specific time, they can use the Globalping Slack app and Slack's message scheduling feature to plan to send the command.
Build your own networking tools: Globalping is open-source and ready to incorporate into your projects. Whether you want to create custom network monitoring tools for your company or develop a helpful utility for yourself, the Globalping API provides the foundation for your creativity.

Conclusion

We hope this guide could show you how to use Globalping to easily and quickly execute ping commands from anywhere worldwide. With several integrations, including the web tool on our website, the CLI tool, and the Slack app, Globalping caters to users with different levels of technical expertise. So whether you need to troubleshoot network issues or test server performance, we aim to give you the tools and flexibility you need with the platform.

As an open-source project, Globalping thrives on community engagement and contributions. If you have feedback, encounter a bug, or wish to contribute by hosting a probe, please visit our GitHub page.

Why not give Globalping a try? Start with our web tool to get quick results at no cost.

Globalping goes live! A community-powered global network testing platform

Dmitriy A. — Mon, 29 May 2023 16:20:42 +0000

We're happy to announce that our new open-source project, Globalping, is officially launched and available to everybody.

Test global latency, ping from any corner of the globe, troubleshoot routing issues, and even investigate censorship worldwide – all completely free.

The Globalping platform

Globalping is a robust platform with a vast network of hundreds (and soon thousands!) of probes running in different countries and cities worldwide. While most of these probes are Docker containers, we also offer hardware probes (mini ARM computers) to our valued donors and occasionally give them away for free.

The probes are hosted by our users in their homes, offices and servers they control. Once a probe is online, it connects to the Globalping API, updates itself, and waits for events – all without user input. Rest assured that the probes don't allow incoming connections or open ports. They also don't require a dedicated IP address, so NAT users can still contribute.

However, to prevent abuse, we have a limit of one probe per public IP.

Thanks to this global network of probes, anyone can make measurement requests via the Globalping API. For example, to run a traceroute from ten European locations, the platform considers all online probes registered in Europe, issues the event to run a local traceroute to ten random probes, and reports the results in real time.

How can you use Globalping?

If you're a developer looking to create tailored integrations and tools, the Globalping API is for you. For everyone else, we are working on a range of official integrations that focus on simplicity and usability – some of which are already available. Let's take a closer look at them!

Want to give Globalping a try? Check out the network web tools on our website to send your first network commands via the Globalping platform.

Globalping CLI

We've designed the Globalping CLI tool to make running measurements and tests a breeze with effortless ways to script automated tests using bash.

To get started, install the CLI tool on your machine: we support all major Linux distributions, MacOS via Homebrew and Windows via Chocolatey. Alternatively, you can download new versions directly from our GitHub page as binaries. (Still, we recommend using a package manager to ensure you get updates automatically.)

After installation, you can use the CLI tool like any other of your regular local tools. Specify a network command and a location from which to run it, and you'll get a response instantly:

$ globalping ping jsdelivr.com from Germany
> EU, DE, Magdeburg, ASN:3209, Vodafone GmbH
PING  (172.67.213.229) 56(84) bytes of data.
64 bytes from 172.67.213.229 (172.67.213.229): icmp_seq=1 ttl=57 time=19.6 ms
64 bytes from 172.67.213.229 (172.67.213.229): icmp_seq=2 ttl=57 time=19.8 ms
64 bytes from 172.67.213.229 (172.67.213.229): icmp_seq=3 ttl=57 time=17.0 ms

---  ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 402ms
rtt min/avg/max/mdev = 17.049/18.791/19.774/1.235 ms

You can also redirect the output to a file and even request the raw json output for easier parsing.

Globalping Slack app

Love the idea of Globalping, but wish it was more accessible to your less tech-savvy teammates? Wouldn't it be great to use it for collaboration within your team? We've got your back and have developed the official Globalping Slack app to do just that!

To get started, install the app in your Slack workspace and use the "/globalping" command or mention the bot "@globalping" to run a command. Then, the app responds by posting the results in the same channel or group chat. Since it utilizes the same user-friendly format as our CLI tool, the transition is seamless.

With the ability to run tests in Slack threads by mentioning the bot, you can actively collaborate with your team in critical moments like outages or troubleshooting CDN routing issues.

We believe this will make our Slack app an indispensable tool for network engineers, DevOps, and technical support teams!

Roadmap

Today's launch marks only the beginning of Globalping's journey, and we have many new and exciting features in the works. Here are just a few of them:

Probe management dashboard and additional limits for users running a probe
API token management system
Continuous monitoring of public Internet infrastructure including detailed CDN and DNS performance data
Many, many more integrations and tools!

Join us on Github, where we collectively contribute to making Globalping a powerful and user-friendly platform.

We are super grateful for the support of our donors and contributors and look forward to a great time collaborating on making the Internet faster for everyone!

DEV Community: Globalping

8 Self-hosted Projects You Can Run at home

Memos

Globalping

n8n

ConvertX

Zipline

BentoPDF

OpenGist

Beszel

Conclusion

Geolocate any IP using latency

Automate Uptime Monitoring with Zapier and Globalping

About the tools

Prerequisites

Step 1 – Automate uptime testing

How can Globalping help with uptime checks?

Setting up the Zap

Adding Globalping to run HTTP tests to our Zap

How much will this cost you?

Step 2 - Send Slack notifications for failed tests

Adding a filter to our Zap

Adding Slack to send notifications

Step 3 – Use AI to summarize test results

Why use AI?

Adding AI to summarize results

Sending AI summaries via email

Globalping Test Summary

Wrapping up

How to get TLS from any location using Globalping

Accessing TLS information with Globalping

Using the Globalping Web UI to get TLS data

Using the Globalping CLI tool to get TLS data

Extracting TLS data from the response

Extracting TLS data in your terminal

Handy use cases for using Globalping to get TLS data

Conclusion

RIPE Atlas and Globalping: Choosing the Right Network Measurement Platform

Introducing the Platforms

Introducing Globalping

Introducing RIPE Atlas

Comparing the Two Platforms

Probe Network

Measurement Types

Measurements and Costs

Internet Health Monitoring

Custom Monitoring Capabilities

Use Cases

Commercial Use

Data Usage

Tools and Integrations

Getting Involved

Is Globalping a RIPE Atlas alternative?

New Globalping feature: Eyeball and data center network tags

Background: Understanding eyeball and data center network tags

Eyeball networks

Data center networks

In action: Using our new eyeball and data center tags

Combining with the world\ location

Combining with a specific location

Stacking filters

Stacking filters and combining locations

Conclusion

Top 10 Slack Apps for DevOps Teams

GitHub – Get updates on GitHub activity

CircleCI – get CI/CD notifications

FireHydrant – Manage incidents

CTO.ai – Slack-first serverless DevOps

json.dev – JSON formatting simplified

Buddy – Easy CI/CD

Globalping – Global network testing

Azure Pipelines – Monitor pipeline activity

AWS chatbot – Monitor and interact with AWS

Truffle – Your FAQ support

Conclusion

Supercharge Your GitOps Workflows with the Globalping GitHub Bot

Exploring the Globalping GitHub bot

Using the Globalping GitHub bot

Example: Ping a target from Berlin using two probes.

Example: Traceroute a target from an AWS probe in Montreal using UDP

Combining with the `world\` location