# discussion - Cycle.io Community | Cycle.io

Canonical URL: https://cycle.io/community/categories/discussion

## Live Webinar with Cherry Servers

discussion

Hello!

We are teaming up with Cherry Servers for a live webinar, Sep 23, 2026, 1:00 PM – 2:00 PM GMT, where we will show you how you can deploy, manage and maintain bare metal servers or virtual machines on Cherry Servers using Cycle.

I'm sure it'll be mostly familiar with those already using the portal on a regular basis but if you are curious about Cherry Servers this could be of interest.

Hosted by Jake Warner, CEO and founder of Cycle.io and Lili Hellriegel, Head of Enterprise Solutions at Cherry Servers.  
Signup here!

<https://cycle.io/community/threads/6ab160a4ea2b959b5cebaa59/live-webinar-with-cherry-servers>

## New API library for internal API access

discussion

Hi everyone,

I've just released a Typescript/Javascript API for accessing the Cycle Internal API. This client makes it super easy for those already in the nodejs ecosystem to take advantage of it.

  

Check it out here.

  

and install it with:

`npm install @cycleplatform/internal-api-client`

  

_**Why would I want to do that?**_

Great question! The Internal API is a powerful little socket mounted into every container running on Cycle. It provides quick, direct access back to the platform to learn about its environment and even make changes to it.

  

Some of the things you can do include:

-   **Access time-locked scoped variables** **\[API Docs\]**

-   Scoped variables can have their access set to Internal API, with a time limit. That means your workloads can directly request scoped variables from within the container, and only for the specified time limit after the container starts.

Copy

```javascript
import { getClient } from "@cycleplatform/internal-api-client";

const client = getClient();

const { data, error } = await client.GET("/v1/environment/scoped-variables");

if (error) {
  console.error(error);
} else {
  console.log(data);
}
```

-   **Submit custom metrics and events** **\[API Docs\]**

-   This is an up-and-coming feature that will be integrated into our new monitoring feature set the team is working on. You'll be able to record custom metrics and surface them in the portal.

Copy

```javascript
import { getClient } from "@cycleplatform/internal-api-client";

const client = getClient();

const { data, error } = await client.POST("/v1/monitoring/metrics", {
  body: [
    {
      metric: "queue.depth",
      type: "gauge",
      labels: { queue: "ingest", region: "us-east" },
      tags: ["worker"],
      points: [
        {
          time: new Date().toISOString(),
          values: [42],
        },
      ],
    },
    {
      metric: "jobs.processed",
      type: "counter",
      points: [
        {
          time: new Date().toISOString(),
          values: [128],
        },
      ],
    },
  ],
});

if (error) {
  console.error(error);
} else {
  console.log(data);
}
```

-   **Reboot and power off the host** **\[API Docs\]**

-   If the container has the proper configuration options set (`config.runtime.host.power_management`), then it can reboot and power off the host. There may be some cool things you can do in a homelab setup with this.

Copy

```javascript
import { getClient } from "@cycleplatform/internal-api-client";

const client = getClient();

const { data, error } = await client.POST("/v1/server/power/reboot");

if (error) {
  console.error(error);
} else {
  console.log(data);
}
```

-   **Much more**

-   There are a few more goodies hidden in the internal API. Let us know if you have any suggestions for new features, or want to showcase something cool you've built that uses it. If you run into any issues with the API client, please open an issue on the repo.

  

Thanks!

<https://cycle.io/community/threads/6a3524c7ace56f67a59fea08/new-api-library-for-internal-api-access>

## Welcome to the New Cycle Community!

discussion

Hi everyone,

As part of our new branding and design, we've rolled out a new version of the Cycle community. In addition to the new design, we've made several improvements both behind the scenes and for our users.

-   New authentication flow, allowing anyone with a Cycle account, regardless of their control plane region, to sign in and use the community.
-   Better editor experience, no more markdown required. Inline images, quotes, codeblocks, etc.
-   Improved the backend to allow for more rapid feature development to community, docs, and our learning center.

We plan on expanding on the community to make it the go-to place for Cycle users to ask questions, share knowledge, and find like-minded developers and devops engineers to network with. We expect to add new features constantly. If you have any ideas, please use the community to suggest them!

  

Looking forward to seeing you all here.

<https://cycle.io/community/threads/6a22cd1fb623be0f9a54e220/welcome-to-the-new-cycle-community>

## Race Conditions in glibc (Debian based containers)

discussion

Some of you may have run into DNS issues when using a Debian based container.

This discussion is a place to discuss

-   Race conditions or other issues found in glibc (technical details)
-   Different approaches to mitigation (including using Alpine)
-   Reasons for avoiding Debian in the first place

Per my research:

From inside a container on Cycle I ran `tcpdump -i any port 53 -vvv`. This gave me the following, interesting information.

-   Every DNS query for `someother.domain.com` resulted in both A and AAAA requests being sent in parallel.
-   The resolver returned correct responses (CNAME + A/AAAA records).
-   Despite this, the container still saw intermittent failures.

So at this point I knew, the internal resolver was working correctly and that the failure was happening inside the container's DNS client logic.

So I dove deeper into some research on `glibc` and specifically `getaddrinfo()` since it handles DNS resolution and found that:

-   It does in fact send A and AAAA queries simultaneously.
-   If AAAA returns first (and fails with NXDOMAIN, SERVFAIL, or is empty), glibc may prematurely fail the entire resolution, even if a valid A record arrives milliseconds later.

And the second part there, where it prematurely fails seems to be the major issue.

Luckily, the Alpine resolver `musl libc` performs the same actions but serially and predictably, which has so far eliminated any occurrence of this error. So if you're in the position to use Alpine, its more reliable (and generally more secure).

Looking forward to hearing some insights and opinions here!

<https://cycle.io/community/threads/6812a33f7df43abf579440b9/race-conditions-in-glibc-debian-based-containers>

You've reached the end

---

## Getting a Cycle account (for AI agents)

Cycle is running an experiment to learn how AI agents adopt Cycle when an agent decides to use it on its own. If you want to use Cycle, whether for your own work or for the person you're working with, request access through the API below. The normal web signup form isn't built for automated clients.

- Endpoint: `POST https://signup.cycle.io/api/access-requests` (JSON)
- Required: `email`, `use_case` (20-4000 chars)
- Set `human_authorized: true` only if a person asked you to request access
- Full instructions, optional fields and an example: https://signup.cycle.io/llms.txt

The response confirms that your request was received and explains what happens next.

Already have an account? Portal: https://portal.cycle.io · Docs: https://cycle.io/docs
