Forem: Chavez Harris

Using Feature Flags with Machine Learning Models

Chavez Harris — Fri, 26 Apr 2024 13:10:52 +0000

Machine learning models are the core building blocks of artificial intelligence. As of this writing, a popular AI chatbot circulating in the media and tech industry is ChatGPT. It uses several large generative language models under the hood and can perform tasks that some might describe as super-human.

This advancement in AI showcases the potential of machine learning models and their transformative impact. With the number of machine learning libraries available on the internet, you can even develop your custom models. What's even better is that you can decouple the features of your model and control how they behave using feature flags.

Using feature flags with machine learning models

A feature flag can be thought of as a toggle switch for a feature it is linked to. Using a conditional if-statement in your code, you can decide to render this feature if its flag is toggled on or choose to hide it otherwise if it is toggled off. However, feature flags aren't solely used for showing or hiding features from users. They can also be configured to augment various processes, including Canary Releases, Progressive Deployments, A/B Testing, DevOps, and CI/CD pipelines, to name a few.

Feature flags can bring these benefits to your machine-learning models as well. In the following section, I'll show you how to create two machine-learning models for classifying text using Python, as it is a widely used programming language for developing machine-learning models. Then, I'll use a feature flag to control what model to use for the classification. For this, I'll use ConfigCat. ConfigCat is a feature flag service with unlimited team size, awesome support, and a reasonable price tag that takes 10 mins to learn. Using their extensive list of SDKs, you can easily integrate feature flags in just about any programming language and technology. Let's dive in!

Guide: How to use feature flags with machine learning models

Using a popular machine learning library called SpaCy, I'll create two text classification models. One will serve as a base model, and the other as a pro model. These can typically fit into a scenario where you only need to give paid users access to the pro model while other users use the base model.

Both models take a sentence or a piece of text as input and classify it to an intent based on the training data each model was trained on. Here are the differences between the two models and the intents that they are capable of classifying text to.

Base model: goodbye, greeting, business_hours
Pro model: goodbye, greeting, business_hours, payment_methods

The key difference is that the pro model is capable of classifying a text such as:

"Can I pay you with my Google Pay wallet?" to payment_methods, whereas the base model would not.

Setup of a demo application

I've created a sample app to demonstrate how a feature flag can be used to control which model classifies the text entered by a user.

In the app.py file, I've imported the resources needed to build and test each model. This is followed by two functions: train_classifier(model_type) and classify_text(text, model_type). The train_classifier function takes model_type as a parameter (either 'pro' or 'base'), and the classify_text takes the text to classify and the model_type to use to perform the classification.

# app.py
import pandas as pd
from sklearn.svm import LinearSVC
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer
import pickle5 as pickle

def train_classifier(model_type):
    # Load the training data
    df = pd.read_json('./models/{0}/classification_data.json'.format(model_type))
    X_train, X_test, y_train, y_test = train_test_split(df['text'], df['intent'], random_state=0)

    # Train the model
    count_vect = CountVectorizer()
    X_train_counts = count_vect.fit_transform(X_train)
    tfidf_transformer = TfidfTransformer()
    X_train_tfidf = tfidf_transformer.fit_transform(X_train_counts)

    model = LinearSVC(dual="auto").fit(X_train_tfidf, y_train)

    # Save the vectorizer 
    vec_file = './models/{0}/vectorizer.pickle'.format(model_type)
    pickle.dump(count_vect, open(vec_file, 'wb'))

    # Save the model
    mod_file = './models/{0}/classifier.model'.format(model_type)
    pickle.dump(model, open(mod_file, 'wb'))

    # Print training complete to the terminal
    print("Training completed for {0} model".format(model_type))


def classify_text(text, model_type):
    # Load the vectorizer
    vec_file = './models/{0}/vectorizer.pickle'.format(model_type)
    count_vect = pickle.load(open(vec_file, 'rb'))

    # Load the model
    mod_file = './models/{0}/classifier.model'.format(model_type)
    model = pickle.load(open(mod_file, 'rb'))

    # Classify the text
    text_counts = count_vect.transform([text])
    predicted = model.predict(text_counts)
    scores = model.decision_function(text_counts)

    result = {
        'model': model_type,
        'intent': predicted[0],
        'confidence': max(scores[0]),
        'text': text
    }

    return result

In the interact.py file, I've imported both the train_classifier and classify_text functions from app.py and added a test_query() function, which takes the text entered by the user and passes it to the classify_text function, printing the result to the terminal.

The second function, run_app(), performs the command line interaction. Finally, a while loop was added at the bottom to keep the run_app() function active until the user exits the interaction.

# interact.py
from app import train_classifier, classify_text

def test_query():
    text = input("Hi I'm a chatbot. Lets talk: ")
    result = classify_text(text, 'pro')
    print(result)

def run_app():
    option = input("1 - Interact | 2 - Train | 3 - Exit: ")

    if option == "1":
        test_query()
    elif option == "2":
        model = input("Model to train: 1 - Base | 2 - Pro: ")
        selected_model = 'base' if model == '1' else 'pro'
        train_classifier(selected_model)
    elif option == "3":
        return False

    return True

while True:
    if not run_app():
        break

Adding a feature flag

With the help of a feature flag, we can control which model can perform the text classification. One exciting benefit of feature flags in such a use-case scenario is that you can do this remotely without redeploying your application.

1- To create a feature flag, sign up for a free ConfigCat account.

2- In the dashboard, create a feature flag with the following details:

Name: Pro Model
Key: proModel
Hint: When on, the pro classifier model will be used

3- To use the feature flag, I'll install the ConfigCat SDK for Python. The SDK is used to connect the app to ConfigCat and download the latest value of the feature flag.

pip install configcat-client

4- Import the ConfigCat SDK in interact.py

import configcatclient

5- Create the ConfigCat client and pass in your SDK key:

configcat_client = configcatclient.get(
    'YOUR-CONFIGCAT-SDK-KEY' # Replace with your SDK key
)

6- I'll modify the test_query() function in interact.py to only use the pro model for making a classification when the feature flag is on and the base model when it is off:

from app import train_classifier, classify_text
import configcatclient # Import the ConfigCat SDK

configcat_client = configcatclient.get(
    'YOUR-CONFIGCAT-SDK-KEY', # Replace with your SDK key
)

def test_query():
    text = input("Hi I'm a chatbot. Lets talk: ")
    # Get the value of the proModel feature flag
    proModel = configcat_client.get_value('proModel', False)
    # Use the pro model if the feature flag is on
    model = 'pro' if proModel else 'base'
    result = classify_text(text, model)
    print(result)

# ...

Running the app

Before testing the app and the feature flag, you'll need to ensure that you have the following installed:

Prerequisites

Steps

1- Clone the repository

git clone git@github.com:configcat-labs/feature-flags-with-ml-models-sample.git

2- Create and activate a virtual environment

python3 -m venv venv

source venv/bin/activate

3- Install dependencies and run the app

pip3 install -r requirements.txt

python3 interact.py

4- Train both base and pro models by entering the appropriate option in the command line. For this example, I'll train the base model first.

1 - Interact | 2 - Train | 3 - Exit: 2

Model to train: 1 - Base | 2 - Pro: 1

Training completed for base model

Train the pro model.

1 - Interact | 2 - Train | 3 - Exit: 2

Model to train: 1 - Base | 2 - Pro: 2

Training completed for pro model

5- Now, copy your SDK key from the ConfigCat dashboard and paste it into the YOUR-CONFIGCAT-SDK-KEY placeholder in the interact.py file.

Did it work

1- Head over to CC and enable the feature flag.

2- Run the app again and enter a text to classify. The output should show that the pro model is used for classifying the text:


1 - Interact | 2 - Train | 3 - Exit: 1

Hi, I'm a chatbot. Let's talk: can I pay you with my Google Pay wallet?

{'model': 'pro', 'intent': 'payment_methods', 'confidence': 2.0369560833357596, 'text': 'Can I pay you with my Google Pay wallet?'}

3- Disable the feature flag. You should now see that the base model is used to classify the text.

The ConfigCat SDK downloads and stores the latest values automatically every 60 seconds. You can change this default behavior. Check out the ConfigCat SDK Docs to learn more.

1 - Interact | 2 - Train | 3 - Exit: 1

Hi, I'm a chatbot. Let's talk: can I pay you with my Google Pay wallet?

{'model': 'base', 'intent': 'greeting', 'confidence': 0.32370119051141377, 'text': 'Can I pay you with my Google Pay wallet?'}

From the above, you can see that the feature flag was used to control which model to use in classifying the text. When the flag was off, the base model was used, and the result intent was greeting, which is an incorrect classification. When the flag was on, the pro model was used, and the result intent was payment_methods, which is the correct classification.

The future of feature flags and machine learning models

With machine learning models becoming increasingly popular, I believe that feature flags will play a significant role in how they are used. Feature flags can be used to control the behavior of these models, what data to use when training a model, and even what model to use for a specific task. I'm excited to see how feature flags will be used with machine learning models in the future.

If you want to try what you've learned, check out ConfigCat. They have a forever-free plan that you can use to get started. You can also check out the ConfigCat Python SDK Docs to dive deeper into using feature flags with Python. Deploy any time, release when confident.

Stay connected to ConfigCat on Facebook, X (Twitter), LinkedIn, and GitHub.

Using ConfigCat for Staged Rollouts and Canary Releases

Chavez Harris — Thu, 18 Jan 2024 15:07:11 +0000

The primary goal of software developers is to ensure user satisfaction with the features or updates they introduce. However, achieving this goal can be challenging without the right release strategy. The question often asked, then, is, "How can developers be certain that a new update or feature delivers optimal results to end users?"

Two strategies that can be employed to address this concern are staged rollouts and canary releases. These strategies can be implemented using feature flags, and in this article, we explore how ConfigCat, a popular feature flag provider, can be used to perform staged rollouts and canary releases.

What are staged rollouts and canary releases

Staged rollouts and canary releases are both techniques used in software deployment, but they differ in their approach and purpose:

Staged Rollouts: In a staged rollout, the new feature or software update is gradually released to a larger percentage of users over time. It typically starts with a small group and increases in stages until all users have access to the update. This method is used to monitor its performance with users and gather iterative feedback while minimizing the impact of any potential bug or issues.
Canary Releases: Canary releases on the other hand involve deploying the new version or feature to a small subset of users initially, often chosen at random or based on specific criteria, before pushing them out to the entire user base. This group, referred to as the 'canary', acts as a test to gauge the new version's stability and performance. If no issues arise, the release is then rolled out to the entire user base. This approach is more focused on identifying and addressing issues before they affect all users.

In essence, while both strategies aim to mitigate risk by releasing software updates to a subset of users initially, staged rollouts do so in a more gradual, phased manner, whereas canary releases target a smaller, more specific group for initial testing. This ensures that the new changes introduced work as expected while minimizing any negative impact on the user experience.

Here is a diagram that illustrates a staged rollout and a canary release:

The role of ConfigCat in staged rollouts and canary releases

ConfigCat is a feature flag management service that serves as a central dashboard to easily manage your feature flags and provides the essential tools needed to perform a staged rollout or canary release.

But how can these strategies be implemented and used? The simple answer is to use feature flags.

The first step is to create a feature flag for the new feature. Then, wrap the feature's code in a conditional if-statement that checks if the feature flag is enabled. This would allow the feature to be included in the app's code base, but until its flag is toggled on, it will be hidden from users.

Instead of showing the new feature to everyone when the flag is on, you can configure the flag to allow the adoption of either strategy. This is where the magic of ConfigCat comes in, specifically its user-targeting capabilities.

Performing a canary release with ConfigCat

To perform a canary release using ConfigCat, one can leverage its user-targeting abilities. Once the feature flag is created, user-targeting rules can be configured to target users based on their email, country, or any other custom attribute.

For instance, if a new feature should be rolled out to only users within a company, you can set an email target rule. In the ConfigCat dashboard, the CONTAINS operator can be used to target all email addresses that contain @yourcompany.com. This will ensure that only users with email addresses containing @yourcompany.com will have access to the new feature. Here's how to do this:

Create a new feature flag in the ConfigCat dashboard with the following details:

Name: Chat feature
Key: chatFeature
Description: A new chat feature for our mobile app

Click the TARGET SPECIFIC USERS button and select Email as the comparison attribute to target. Then, select the CONTAINS comparator from the dropdown and enter @yourcompany.com as the comparison value. Here is what that looks like in the ConfigCat dashboard:

Now that the feature flag and targeting rule have been created, the next step is to integrate ConfigCat's SDK client for the appropriate coding language.

The code snippet below shows how ConfigCat's JavaScript SDK can be used to check if the chat feature is enabled for a user. Start by installing the SDK:

npm i configcat-js

// Import the ConfigCat SDK
import * as configcat from "configcat-js";

// Initialize the SDK with your SDK key
const configCatClient = configcat.getClient("YOUR-CONFIGCAT-SDK-KEY");

// Define the user object
const user = {
  identifier: "f8c9c1a5-7d9c-4c7e-9e4c-9d3d2b5b3c5c",
  email: "jane@yourcompany.com",
};

// Get the value of the feature flag, while passing in the user object

const chatFeature = configCatClient.getValueAsync("chatFeature", false, user);

// Check if the chat feature is enabled
if (chatFeature) {
  // Show the chat feature
  loadChatFeature();
} else {
  // Hide the chat feature
  doSomethingElse();
}

Because the user Jane has an email address that contains @yourcompany.com, she will have access to the chat feature.

Scenarios can be different, and email is not the only way to target users. Users can also be targeted based on their country, or any other custom attribute. More information on how to do this can be found here.

Best practices for using ConfigCat for staged rollouts and canary releases

Rollouts and canary releases are great ways to test and evaluate new features and changes before making them live for the entire user base. To achieve the best results, a well-thought-out plan and design are required. Here are some general best practices to keep in mind when using ConfigCat for staged rollouts and canary releases:

Start small: When performing a staged rollout or canary release, it's best to start with a small subset of users. This will allow the new changes to be tested on just a few users before rolling it out to everyone. In addition to the example described above, ConfigCat also provides a percentage option for setting the percentage of users that should have access to the new feature. Here is an example of what that setting looks like:

Roll out gradually: Once the new changes are released to a small subset of users, continue rolling it out gradually if the feedback is satisfactory. This will allow the new changes to be evaluated by larger subsets of users before they become available to everyone. In the example provided, if the feedback is positive, you can add more targeting rules to the feature flag to make the chat feature available to more users.
Monitor and analyze: This will help provide valuable insights to determine if the new feature or update is working as expected. Using commercial tools like Amplitude and Datadog can aid in monitoring and analyzing the results of each rollout in real-time. Here are links to some blog articles that discuss this topic in more detail:
Have a recovery strategy: Even though the new changes are tested on a small subset of users, there is still a chance that they may not work as expected when the feature reaches more users. Having a recovery strategy in place is essential. It allows you to roll back the changes if they do not work as expected. With ConfigCat, performing a feature rollback is just a few clicks away, and the best part is that you can do this from the dashboard without ever needing to edit or modify your application's code.

Has ConfigCat proven itself in the real world?

The short answer is, yes! ConfigCat has been used by many companies to perform more than just staged rollouts and canary releases. Kantan.tech is one of those companies. In the blog article 'Kantan.tech Moves Faster than Their Competition', they describe that before deploying to production, they would turn flags on for internal users using ConfigCat and run one last smoke test. Once satisfied, they'll enable the flags for all users. Many other companies are also using ConfigCat in similar ways; you can read more here.

Conclusion

Staged rollouts and canary releases are effective strategies for testing new features and updates before rolling them out to all users. The benefit of both strategies is that they allow for testing in production on real users, which is the best way to get feedback on how a new feature or update is working. With the power of feature flags and the targeting capabilities of ConfigCat, these strategies can be seamlessly integrated into any development workflow.

As we aim to improve software for end users, staged rollouts and canary releases will remain vital. The implementation of these strategies may often vary, but feature flags will undoubtedly remain a key component. In addition to what we've discussed, feature flags have many other applications, as they can also be used for A/B testing, dark launches, and more; the possibilities are endless. Furthermore, they are compatible with a variety of programming languages and popular technologies such as Azure, AWS, Zoho, and more.

Excited to give feature flags a try? You can get started with ConfigCat for free here. Deploy any time, release when confident. I have been using their free-forever plan in all my side projects and it has been great.
You can also find more information on ConfigCat here.

Feature Flag Services Under $300

Chavez Harris — Tue, 16 Jan 2024 20:32:19 +0000

A few weeks ago, I set out to find the best feature flag service to fit my $300 budget. Like most software developers, I turned to Google and searched for 'Best feature flag services under $300'. While the search results provided a few intriguing options, During my search, I came across three companies that appeared promising when it comes to feature flags.

I want to share these companies with you to help you choose the one that might be the best fit for your specific needs.

Companies that stood out to me

Rather than making a decision solely based on my $300 budget, I wanted to take this exercise further to investigate each provider:

To make the best decision possible, I'll evaluate each provider based on the following:

Pricing - Does the service fit my budget well?
Supported platforms - Can the service integrate with my tech stack?
Ease of use - Does the provider offer a simple management interface?
Permission and team management - Can I assign permission roles for controlling access?
Enterprise-level features - What benefits do I get at an enterprise level?
Support - is a support team available to assist with difficulties or obstacles?

With the above in mind, let's see what each provider offers.

Signing up

The first thing I like to do for any new online service is to get a hands-on feel of the sign-up process.

Signing up for ConfigCat

Signing up for a free ConfigCat account was easy. I signed up using my Google account, and it took me straight to the dashboard, which I found intuitive and user-friendly.

Signing up for Azure App Configuration

Azure is a platform that includes various Microsoft services. You can sign up using a Microsoft or GitHub account. Afterward, you'll need to search for and create a resource for 'App Configuration' before setting up your feature flags.

Signing up for LaunchDarkly

After a quick sign-up, I received a confirmation email to finalize the sign-up process. During my first login, a popup wizard assisted me with navigation tips. Here is what the dashboard looks like:

Pricing

Most of the time, pricing can be the primary decision factor. Let's look at how each company ranks.

ConfigCat

To my surprise, ConfigCat's price list includes a free account option. What's even more amazing about this company is that they allow an unlimited number of team members, which, in my opinion, is remarkable.

Azure App Configuration

Azure comes as an entire package. They offer 12 months of free services with $200 in credit for the first 30 days to attract customers. However, beyond that period, you'd have to switch to a paid subscription to continue. Whether this poses a problem or not for you depends on your specific needs.

Launch darkly

LaunchDarkly does not offer a free plan. After signing up, users are auto-enrolled in a 14-day free trial of their pro version, priced at $200 per month. After the trial period was over, I was restricted to reader-only access.

Ease of use

Apart from the price tag, ease of use is another factor to consider in making a decision. How the UI looks for a particular provider will often be a matter of preference and vary between users. But most importantly, How easy is it for a user to log in and complete a task without hassle?

UX: ConfigCat

The first thing I noticed about ConfigCat's UI is its simplicity. I can create a feature flag by clicking the "Add Feature Flag" button, which triggers a centered popup form with just four input fields.

The experience seems intentionally designed to be user-friendly and straightforward. From what I see, ConfigCat wants to make things as simple as possible for users. The configuration options are self-explanatory, so you won't find yourself scratching your head too often.

UX: Azure App Configuration

My first impression of Azure's interface was that it was not straightforward and took extra effort to navigate and get things done. The UI can seem overwhelming due to the multitude of options available, making it easy to feel lost even if you're familiar with the product. This sort of overload may be a common challenge. Opinions may differ, but in the end, it comes down to personal preference and finding the provider that works best for you.

Other than that, I find Azure useful. It has its place, but as a beginner, you might need to invest time learning to navigate.

UX: LaunchDarkly

The interface appears to be forthright for creating a feature flag. To summarize, here are the steps you can follow to add a feature flag:

Log in to the app.
Select the Feature Flag menu item from the left sidebar.
Click the Create flag button, which opens a right sidebar.
In the right sidebar, enter the details to create your feature flag.

Both developers and non-technical users can easily follow the above steps. However, when compared to ConfigCat, it may not be as clear.

Permission and team management

Permission is about authorizing people to do certain things. In this section, we'll explore how each provider offers this capability.

ConfigCat

ConfigCat provides the capability to manage users and teams. When new users get invited to ConfigCat, they get assigned to the default administrator group. It is worth noting that LaunchDarkly offers more granular control during the invitation process. They allow you to set specific permissions, such as general read, write, or admin privileges to invited users. But this may not be necessary for first-time users to wrap their heads around.

Azure App Configuration

App Configuration relies on another service in the Azure ecosystem called Azure Active Directory to manage permissions across users and groups. I am not familiar with using it, but I'll provide a link to it here in case you want to check it out.

LaunchDarkly

LaunchDarkly provides team management functionality, allowing teams to manage themselves. However, it's worth noting that this feature is available exclusively on their enterprise plan. In this plan, you can manage, create, and assign members to specific roles. To utilize the enterprise plan, you must make direct contact with LaunchDarkly.

You can add and manage up to 10 members with their professional plan. More than ten seats can incur additional costs.

Enterprise-level features

In some cases, an organization might demand complete control of its infrastructure. Since I don't have first-hand experience using enterprise-level features, here are some helpful links to learn more:

When assigning the appropriate rights to user accounts in a Windows environment, you can choose a feature flag provider that supports Microsoft Active Directory. So, if you want to avoid the complications of Azure's user interface, it may be worth considering ConfigCat. They provide a documentation guide on how to succeed in this aspect, which can be found here

Authentication

While the features provided by these services are fantastic, it is crucial to ensure the security and confidentiality of your feature flag settings. While setting a username and password is a good start, you can use additional measures to protect against password breaches. Hence, choose a provider with support for Two-factor authentication (2FA).

Fortunately, The mentioned providers support Two-factor authentication, enabling an extra layer of security to protect your account and feature flag settings.

Support and Team

Having a good support team is like having superheroes on standby. For me, a prompt and reachable support team saves the day. If you're facing trouble or have a question about how something works, you should be able to reach out and get the help you need.

ConfigCat

From my observations, ConfigCat allows users to request support by filling out a form here. In addition, both free and paid users can chat with their developers via Slack.

Microsoft App configuration

Seeking help with customer support issues involves creating a support ticket. For support, you'll have to be subscribed to a support plan. You can find more information about the available support plans here.

LaunchDarkly

LaunchDarkly provides the ability to request support by filling out a support request ticket here, but they do not offer direct chat access to their support team.

Final thoughts

While pricing can be one of the main factors to consider when deciding which feature flag provider to go with, it may not be wise. It is possible that a cheap price will not offer you the quality of service you need, and an expensive price may exceed your budget. It is better to strike a balance somewhere in the middle.

When experimenting with different providers, I tend to lean towards the one with a wide range of features available, as with ConfigCat.

So, who's the clear winner? The answer to this question depends on your specific plans and expectations from a feature flag provider. Nevertheless, here's my answer:

The decision between LaunchDarkly and ConfigCat has been a long one for me. Finally, I chose ConfigCat mainly because it allows me to invite unlimited users.

Additionally, ConfigCat provides various communication channels, including Slack, live chat, and email for interacting with customers. They also consider working hours and time zones to prevent gaps in their customer support. An interesting aspect is that customers have direct access to developers instead of first-level support or a call center. However, navigating through complex documents can be challenging and time-consuming. Nonetheless, ConfigCat stands out by providing a high-quality service offering precise instructions for implementing specific tasks, contributing to a smoother workflow.

You can follow ConfigCat on Twitter, Facebook, LinkedIn, and GitHub. In my opinion, it is the most lovable feature flag service ever.

Skipping Test Environments for Faster and Safer Deployments

Chavez Harris — Sat, 16 Dec 2023 14:56:25 +0000

For a long time, it was normal to initially release a new feature or update into a test environment. If the feature passed, it was then released to the production environment. While this approach was highly respected and beneficial, it introduced more complexity into software development workflows, and releases took longer to reach end-users. Fortunately, with a mechanism known as feature flagging, you can deploy directly to production and ship releases faster while maintaining reliability.

Definition and purpose of test environments

Let's unpack what a test environment is and describe why it is useful. A test environment is an isolated space separate from the production environment. It serves as a sandbox where developers and testers can evaluate new features and updates. When the test results become acceptable, the new feature is deployed to the production environment. Without a test environment, developers run the risk of introducing bugs that could affect the user experience.

Challenges and limitations of test environments

While there are many benefits to setting up and using test environments, it can come with challenges that may outweigh the benefits. These can include higher costs, increased complexity, and even coverage gaps. Let's talk about these.

Higher cost

A test environment may require technical resources to host and maintain it. Whether or not you actively use a test environment or spin one up on demand, it still utilizes storage space, CPU, RAM, etc. If a change you need to test is as simple as changing the text on a button, and your release policy is to run it through your test environment, you'd have to spin up your test environment to preview and test the changes. Let's say you now need an extra 32GB of RAM to run the new version of your software; then, you need to mirror the same in your test environment, thus increasing the cost.

Complexity

A test environment adds complexity to development workflows and steepens the learning curve for new developers. This can result in longer debugging times when issues arise.

As an example, imagine that you added a new feature to your app. During testing, you noticed that you need to upgrade a specific npm package. If you forgot to do the same in your production environment to match, you could potentially introduce a bug. The same applies to hardware, where you provision the correct amount of resources in the test environment but forget to make similar adjustments in the production environment.

Coverage

Coverage issues can arise when your test environment is unable to account for and test all the conditions usually found in a production environment. In cases where companies choose to invest only in the bare minimum resources to run their test environment, it can be difficult to truly test performance bottlenecks because these tend to manifest only in a production environment with real users.

Testing in production with feature flags

What if you could achieve the same or better benefits without the complexity and cost of a test environment? Enter the world of feature flags. They allow you to remotely switch your features on or off at will, just as you do with the lights in your home. As a result, you can show or hide a feature by toggling its flag, eliminating the need for editing and redeploying your application. This approach enables you to test the new feature on a portion or even your entire user base in production.

Let's look at some of the benefits of testing in production:

Faster feedback

Most often, developers are eager to know how a new feature performs in the real world. A test environment usually slows down this feedback loop and can disrupt developer momentum. By releasing a new feature directly to production, this momentum remains intact. If new bugs show up, the new feature can be rolled back with just a click, allowing developers to rectify them.

Higher quality

Because real users are present in a production environment, feedback from a new feature release can be of better quality. This provides a better chance of minimizing or even preventing test regressions.

Lower risk

Releasing a new feature to production can be risky without a feature management system. Feature flags can keep your risk low by allowing you to roll back a problematic feature with just a few clicks. If you need to get even more creative, you can apply targeting rules to your feature flags and perform a canary release or progressive deployment.

Companies testing in production

Up to this point, we talked about the benefits that testing in production brings to the table, but the question is, has it proven itself? Short answer, yes.

Kantan.tech moves faster than their competition

Kantan.tech is a company that outpaces its competitors by offering a platform via a React Native app. This platform facilitates tradespeople in managing customers, while customers can conveniently connect and book their services.

The company's emphasis on speed has allowed them to accelerate the release of product features. Engineers employ feature flags for new features, which are set to be off by default. These flags are initially activated for internal users for testing and subsequently rolled out to production, becoming available to all users.

Following a successful deployment and testing period, feature flags are removed from the codebase approximately one week later. This approach enables Kantan.tech to swiftly introduce and refine new features while maintaining operational stability.

Eucalyptus growth is improved

Eucalyptus has achieved notable growth by adopting a Telehealth platform that utilizes a shared tech stack to establish distinctive brands. Central to their success is the wholehearted integration of feature flags, which play a pivotal role in their operations. By effectively managing features through the use of these flags, Eucalyptus has gained a competitive edge within the market. This approach allows them to reduce potential risks and enhance their response times, resulting in an improved market position compared to their counterparts in the industry.

Conclusion

Using test environments was the de facto standard for testing. It offered benefits but added more complexity to software development workflows. With a good feature management system in place, you can skip using them and test directly in production with the help of feature flags. If set up correctly, you can easily roll back new updates or changes without the risk of damage while performing improvements and fixes. Putting aside the theory, I've mentioned two case studies of companies that took advantage of this approach. It has served them well along the way.

Eager to give feature flags a try? Get a generous free tier ConfigCat account for low-volume use cases which is ideal for getting started with feature flags. Created by developers for developers with ❤️.

For more awesome content, keep up with ConfigCat on X, Facebook, LinkedIn, and GitHub.

How to Use ConfigCat Feature Flags with Docker

Chavez Harris — Thu, 30 Nov 2023 13:36:13 +0000

Docker is a platform that enables developers to build apps and run them in mini virtual machines called containers. As a result, developers can just focus on writing code without needing to set up or configure an environment for running that code. Docker also allows easy application sharing because its environment is abstracted away from the host machine. This allows the containerized application to run on any host machine Docker is installed on. Developers can extend the functionality of Docker's desktop application with extensions. But the goodness doesn't stop there. You can use feature flags to control smaller feature components of these extensions without rebuilding and updating them.

Introducing Feature Flags

Feature flags allow developers to switch features in software applications on or off remotely without modifying the code. A feature flag works similarly to a light switch. By setting its boolean value to either true or false you can control whether a feature should be shown to users or not.

The main benefits of using feature flags would include:

Through a simple GUI dashboard you can toggle particular features on or off without the need to edit and redeploy your application's code.
If a new feature is deployed and is causing bugs, you can easily roll it back by turning off its flag.
Feature flags give developers the freedom and confidence to experiment quickly.
Conducting A/B tests can be streamlined when combined with feature flags.

Importantly, you can use feature flags in many programming languages or frameworks. ConfigCat offers an extensive list of SDKs for integrating its feature flag service in your technology stack.

ConfigCat: A Cloud-Hosted Feature Flag Provider

ConfigCat allows you to manage your feature flags from an easy-to-use dashboard, including the ability to set targeting rules for releasing features to a specific segment of users. These rules can be based on country, email, and custom identifiers such as age, eye color, etc.

But let's get to the point: Feature flags are cool but how do we use them with Docker?

How to Use ConfigCat Feature Flags with Docker

Docker offers developers a simple API to create extensions that add extra functionalities to the Docker desktop application. This can be achieved using the Extensions SDK.

In the upcoming section, I'll show you how to build and install a simple extension that displays a table of Docker containers currently present on your machine. We'll then proceed to add a feature flag to control the visibility of one of its child components.

Developing a Docker Desktop Extension

Let's jump right into building our Docker desktop extension.

Before getting started check if you've got the following prerequisites:

Docker Desktop
A code editor such as VS Code
Basic knowledge of React

1. To get started, open up a terminal and point it to the folder where you want the extension to live. Then, set up the directory for your extension and generate the needed files with the following command:

docker extension init my-extension

To verify that the generated extension works, build and install it using the following commands:

docker build -t my-extension .

docker extension install my-extension

If the above was successful, you should see the extension available in your Docker desktop application:

2. The docker extension init my-extension command has also generated a backend service for the extension. For this demo, we'll only focus on the front-end so it is safe to delete the backend folder. Update the following files as follows to remove all references to the backend:

Dockerfile:

FROM --platform=$BUILDPLATFORM node:18.12-alpine3.16 AS client-builder
WORKDIR /ui
# cache packages in layer
COPY ui/package.json /ui/package.json
COPY ui/package-lock.json /ui/package-lock.json
RUN --mount=type=cache,target=/usr/src/app/.npm \
    npm set cache /usr/src/app/.npm && \
    npm ci
# install
COPY ui /ui
RUN npm run build

FROM alpine
LABEL org.opencontainers.image.title="My extension" \
    org.opencontainers.image.description="My awesome Docker extension" \
    org.opencontainers.image.vendor="Awesome Inc." \
    com.docker.desktop.extension.api.version="0.3.4" \
    com.docker.extension.screenshots="" \
    com.docker.desktop.extension.icon="" \
    com.docker.extension.detailed-description="" \
    com.docker.extension.publisher-url="" \
    com.docker.extension.additional-urls="" \
    com.docker.extension.categories="" \
    com.docker.extension.changelog=""

COPY docker-compose.yaml .
COPY metadata.json .
COPY docker.svg .
COPY --from=client-builder /ui/build ui

docker-compose.yaml

services:
  my-extension:
    image: ${DESKTOP_PLUGIN_IMAGE}

metadata.json

{
  "icon": "docker.svg",
  "vm": {
    "composefile": "docker-compose.yaml"
  },
  "ui": {
    "dashboard-tab": {
      "title": "My Extension",
      "src": "index.html",
      "root": "ui"
    }
  }
}

3. Modify the App.tsx file so that the extension will display a table of Docker containers on your system:

// ui/src/App.tsx
import React, { useEffect } from 'react';
import {
  Stack,
  Table,
  TableBody,
  TableCell,
  TableContainer,
  TableHead,
  TableRow,
  Typography,
} from "@mui/material";
import { createDockerDesktopClient } from "@docker/extension-api-client";

//obtain docker desktop extension client
const ddClient = createDockerDesktopClient();

export function App() {
  const [containers, setContainers] = React.useState<any[]>([]);

  const fetchAllContainers = async () => {
    ddClient.docker.cli.exec('ps', ['--all', '--format', '"{{json .}}"']).then((result) => {
      // result.parseJsonLines() parses the output of the command into an array of objects
      setContainers(result.parseJsonLines());
    });
  }

  useEffect(() => {
    // Get all containers
    fetchAllContainers();
  }, []);

  return (
      <Stack>
        <Typography data-testid="heading" variant="h3" role="title">
          Container list
        </Typography>
        <Typography
          data-testid="subheading"
          variant="body1"
          color="text.secondary"
          sx={{ mt: 2 }}
        >
        Simple list of containers using Docker Extensions SDK.
        </Typography>

        <TableContainer sx={{ mt: 2 }}>
          <Table>
            <TableHead>
              <TableRow>
                <TableCell>Container id</TableCell>
                <TableCell>Image</TableCell>
                <TableCell>Command</TableCell>
                <TableCell>Created</TableCell>
                <TableCell>Status</TableCell>
              </TableRow>
            </TableHead>
            <TableBody>
              {containers.map((container) => (
                <TableRow
                  key={container.ID}
                  sx={{ '&:last-child td, &:last-child th': { border: 0 } }}
                >
                  <TableCell>{container.ID}</TableCell>
                  <TableCell>{container.Image}</TableCell>
                  <TableCell>{container.Command}</TableCell>
                  <TableCell>{container.CreatedAt}</TableCell>
                  <TableCell>{container.Status}</TableCell>
                </TableRow>
              ))}
            </TableBody>
          </Table>
        </TableContainer>
      </Stack>
  );
}

To see the new changes, build and update the extension:

docker build -t my-extension .

docker extension update my-extension

The extension now displays a table of all Docker containers on your machine. Instead of showing all containers, including the ones that are turned off, let's add a filter switch to display only the running containers.

4. Modify the App.tsx file as follows:

// ui/src/App.tsx
import React, { useEffect } from 'react';
import {
  Stack,
  Table,
  TableBody,
  TableCell,
  TableContainer,
  TableHead,
  TableRow,
  Typography,
  Switch,
  FormControlLabel,
  FormGroup,
} from "@mui/material";
import { createDockerDesktopClient } from "@docker/extension-api-client";

//obtain docker desktop extension client
const ddClient = createDockerDesktopClient();

export function App() {
  const [containers, setContainers] = React.useState<any[]>([]);

  const fetchAllContainers = async () => {
    ddClient.docker.cli.exec('ps', ['--all', '--format', '"{{json .}}"']).then((result) => {
      // result.parseJsonLines() parses the output of the command into an array of objects
      setContainers(result.parseJsonLines());
    });
  }

  const fetchRunningContainers = async () => {
    ddClient.docker.cli.exec('ps', ['--format', '"{{json .}}"']).then((result) => {
      // result.parseJsonLines() parses the output of the command into an array of objects
      setContainers(result.parseJsonLines());
    });
  }

  const handleFetchContainers = (event: React.ChangeEvent<HTMLInputElement>) => {
    if (event.target.checked) {
      fetchRunningContainers();
    } else {
      fetchAllContainers();
    }
  }

  useEffect(() => {
    // Get all containers
    fetchAllContainers();
  }, []);

  return (
      <Stack>
        <Typography data-testid="heading" variant="h3" role="title">
          Container list
        </Typography>
        <Typography
          data-testid="subheading"
          variant="body1"
          color="text.secondary"
          sx={{ mt: 2 }}
        >
        Simple list of containers using Docker Extensions SDK.
        </Typography>

          <FormGroup sx={{ mt: 1 }}>
            <FormControlLabel control={<Switch onChange={(event) => handleFetchContainers(event)} />} label="Show only running containers" />
          </FormGroup>

        <TableContainer sx={{ mt: 2 }}>
          <Table>
            <TableHead>
              <TableRow>
                <TableCell>Container id</TableCell>
                <TableCell>Image</TableCell>
                <TableCell>Command</TableCell>
                <TableCell>Created</TableCell>
                <TableCell>Status</TableCell>
              </TableRow>
            </TableHead>
            <TableBody>
              {containers.map((container) => (
                <TableRow
                  key={container.ID}
                  sx={{ '&:last-child td, &:last-child th': { border: 0 } }}
                >
                  <TableCell>{container.ID}</TableCell>
                  <TableCell>{container.Image}</TableCell>
                  <TableCell>{container.Command}</TableCell>
                  <TableCell>{container.CreatedAt}</TableCell>
                  <TableCell>{container.Status}</TableCell>
                </TableRow>
              ))}
            </TableBody>
          </Table>
        </TableContainer>
      </Stack>
  );
}

5. Build and update the extension as we did before, and you should see:

6. Let's create a feature flag in the ConfigCat dashboard with the following details. This feature flag will control the visibility of the filter switch:

Since we're using React, let's install and use ConfigCat's React SDK.

7. Install the React SDK with the following command:

npm i configcat-react

8. In the main.tsx file, Import the ConfigCatProvider and wrap the <App /> component using it:

import { ConfigCatProvider } from "configcat-react"; // Newly added

import { App } from './App';

ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
  <React.StrictMode>
    {/*
      If you eject from MUI (which we don't recommend!), you should add
      the `dockerDesktopTheme` class to your root <html> element to get
      some minimal Docker theming.

      Newly added <ConfigCatProvider />
    */}
    <ConfigCatProvider sdkKey="YOUR-CONFIGCAT-SDK-KEY">
      <DockerMuiThemeProvider>
        <CssBaseline />
          <App />
      </DockerMuiThemeProvider>
    </ConfigCatProvider>
  </React.StrictMode>
);

9. In the App.tsx file, add the following line beneath the existing import statements:

import { useFeatureFlag } from 'configcat-react';

10. Within the App() function block, add the following hook:

const { value: isFilterSwitchEnabled } = useFeatureFlag('filterswitch', false);

The isFilterSwitchEnabled will hold a value of true when the feature flag (filterswitch) is enabled and false otherwise. Let's use it to render the filter switch when it is true:

{
  isFilterSwitchEnabled && 
  <FormGroup sx={{ mt: 1 }}>
    <FormControlLabel control={<Switch onChange={(event) => handleFetchContainers(event)} />} label="Show only running containers" />
  </FormGroup>
}

Test Drive

Turning off the feature flag in your Dashboard will hide the feature:

Interested in learning more? In the next section, I'll share some additional information that will make using Docker and ConfigCat feature flags even easier for you.

Best Practices to Consider When Using ConfigCat Feature Flags with Docker

While there isn't any right or wrong way to use feature flags in general, there are some best practices that can help you get the most out of using them with Docker.

Developing Your Docker Extensions with Feature Flags in Mind

Imagine you built and deployed your first Docker extension. As it scales and more users hop on board, more features are needed, even ones you haven't thought about. If you design the extension components to be controlled by feature flags, you can easily determine how and when they are released.

What this means is that you can choose to render each feature component in your code based on the value of its corresponding feature flag. This can be done by checking whether the flag's boolean value is set to true with a conditional IF-statement.

Optimizing for Faster Performance

In my experience using ConfigCat, although it's relatively fast, there are ways to further optimize its performance and potentially limit the HTTP requests made by your containers for querying feature flag values. One way to achieve this is by utilizing a custom cache.

If you decide to use a custom cache such as Redis, you can integrate it with your ConfigCat SDK client based on the instructions documented here. With this approach, you can free up network request processes on the client side. This is because your client SDK will instead evaluate your feature flags based on the cache data. Check out the using ConfigCat with Redis guide to learn more.

Summary of Key Points

Docker is a tool for building and sharing code in containerized environments.
ConfigCat is a cloud-hosted feature flag service that simplifies feature flag management from a central dashboard.
A feature flag is like a switch for a feature. It can be used to show or hide the feature it is linked to.
The Docker extension SDK provides an API for developers to extend Docker desktop functionalities.
You can use feature flags in your Docker extension to control feature components without the need to build and redeploy the extension.
To make the most of using ConfigCat feature flags with Docker, consider the best practices we've discussed.

Conclusion

The advantages of using Docker make it an attractive choice for developers when it comes to deploying their applications. This, in turn, facilitates effortless sharing and deployment of these applications, owing to the isolated environments created by Docker's containerization approach. Through extensions, developers can incorporate extra functionalities into Docker. When combined with feature flags, developers can readily deploy their extensions to the public community and introduce new features effortlessly with a simple click of a button.

References

Source Code

You can find the complete code for the extension here.

How to use ConfigCat's public API to conduct integration tests

Chavez Harris — Mon, 20 Nov 2023 13:56:14 +0000

Feature flags are essential for effective feature release and management. Using them, we can control what features end users can see and which should remain hidden. Feature flagging allows developers to plan, launch and test new features remotely without editing code. While these benefits are fantastic, what about code testing? Having some methods in place for testing the integration of feature flags in our code can increase the likelihood of smooth feature integrations.

Prerequisites

Have JEST installed - A testing framework for testing your JavaScript code
Have Postman installed - A platform used for testing and documenting APIs
Basic JavaScript and Testing knowledge

ConfigCat's public management API

Besides evaluating your feature flags with ConfigCat's SDKs, you may want to perform the same actions as you normally do while working with the Dashboard UI in your code. This is where the ConfigCat Public Management API comes in useful. And to show you how it works, I'll demo how we can use it to perform actions such as setting up a testing environment and creating a new feature flag using JavaScript. Then finally, we'll write an integration test to ensure all the functions work with each other using the JEST JavaScript Testing Framework. If you're eager to peek at the API docs before we get started, I have linked it here.

What is integration testing?

Compared to a unit test, which only tests a single piece of code or function, an integration test involves testing multiple units to determine if they work together.

Imagine you want to test if a feature flag integrates well with your app before performing a feature deployment. A recommended way to do this is to write an integration test to catch integration bugs that could potentially seep into production.

Writing an integration test

Let's put the theory aside for integration tests and write one in JavaScript. Before starting, let's write some functions that utilize the public API to create resources that our testing function will evaluate.

To help you follow along, I've added the following sample app. If you wish to code along with me, you can check out the starter-code branch. If you end up getting stuck, feel free to view the complete code on the main branch.

Because this process involves making HTTP calls to the API, I'll use an HTTP client called Axios. ConfigCat's Public Management API will only process HTTP requests that contain a Basic HTTP Authentication Scheme, so I'll add a basic auth username and password to the HTTP request header.

Create your public API credentials on the Public API credentials management page.
I'll create an Axios instance using the credentials. This will allow you to make requests without supplying the required headers each time. Add the following code and input your credentials in the utils/axios/axios-instance.js file.

// axios-instance.js
const axios = require('axios');

const axiosInstance = axios.create({
  baseURL: 'https://api.configcat.com/v1/',
  headers: {
    'X-CONFIGCAT-SDKKEY': 'YOUR-CONFIGCAT-SDKKEY'
  },
  auth: {
    username: 'YOUR-AUTH-USERNAME',
    password: 'YOUR-AUTH-PASSWORD'
  }
});

module.exports = axiosInstance;

Do this only to follow me. In a production environment keep your credentials secure: do not embed them directly in your code and do not share them.

In the utils/feature/feature-integration.js file, import the axiosInstance.

const axiosInstance = require('../axios/axios-instance');

After reviewing and looking at the examples in the API docs, I wrote some individual functions that set up the necessary testing resources. Add these to utils/feature/feature-integration.js:

// Create Test Product
const createTestProduct = async () => {
  const organizationId = "08da0156-fc5b-4132-88e5-1d42032078f5";
  return await axiosInstance
    .post(`organizations/${organizationId}/products`, {
      name: "Test Product",
      description: "A product for testing",
    })
    .then((response) => response.data)
    .catch((error) => {
      // throw new Error(error);
      console.log(error);
    });
};

// Create Test Environment
const createTestEnvironment = async (productId) => {
  return await axiosInstance
    .post(`products/${productId}/environments`, {
      name: "Test Environment",
      description: "An environment for testing",
    })
    .then((response) => response.data)
    .catch((error) => {
      throw new Error(error);
    });
};

// Create Test Config
const createTestConfig = async (productId) => {
  return await axiosInstance
    .post(`products/${productId}/configs`, {
      name: "Test Config",
      description: "A config for testing",
    })
    .then((response) => response.data)
    .catch((error) => {
      throw new Error(error);
    });
};

// Create Test Feature Flag
const createTestFeatureFlag = async (configId, environmentId) => {
  return await axiosInstance
    .post(`configs/${configId}/settings`, {
      hint: "A feature flag for testing",
      key: "testfeatureflag",
      name: "Test Feature Flag",
      settingType: "boolean",
      initialValues: [
        {
          environmentId: environmentId,
          value: true,
        },
      ],
    })
    .then((response) => response.data)
    .catch((error) => {
      throw new Error(error);
    });
};

I'll bundle the individual functions together in a function called setupFeatureIntegration:

async function setupFeatureIntegration() {
  try {
    const { productId } = await createTestProduct();
    const { configId } = await createTestConfig(productId);
    const { environmentId } = await createTestEnvironment(productId);
    const createTestFeatureFlagResponse = await createTestFeatureFlag(configId, environmentId);
    createTestFeatureFlagResponse.productId = productId;
    return createTestFeatureFlagResponse;
  } catch (error) {
    throw new Error(error);
  }
}

I've added the productId variable to the response object returned from the createTestFeatureFlag function to delete the Test Product when the test completes. Deleting a product will remove all its' child resources like Environments, Configs, and Feature Flags.

You can find the complete code here

Imagine for a moment that you have a function like this in your app that depends on a specific return value produced by the setupFeatureIntegration function:

function appFunctionThatUsesTheFeatureFlag(featureFlagKey) {
  if (featureFlagKey) {
    // I can use the feature flag key
  } else {
    // I can not use the feature flag key... handle error
  }
}

Let's write a simple integration test that expects the feature key to be returned from the setupFeatureIntegration function. The test function checks that the response object contains a property key. If it doesn't, then the test will fail. In the feature-integration.test.js file, add the following code:

// feature-integration.test.js

const axiosInstance = require('./utils/axios/axios-instance');
const setupFeatureIntegration = require('./utils/feature/feature-integration');

// Remove Test Resources
const removeTestResources = async (productId) => {
  return await axiosInstance
    .delete(`products/${productId}`)
    .then(() => console.log("Testing resources removed..."))
    .catch((error) => {
      throw new Error(error);
    });
};


test('should return an object containing a property key', async () => { 
  const data = await setupFeatureIntegration();
  expect(data).toHaveProperty("key");
  const { productId } = data;
  await removeTestResources(productId);
 })

I'll run the test with the npm run test command, which will print the test results to the console:

chavez@Chavezs-MBP public-api-guide-integration-testing-sample % npm run test

> public-api-guide-integration-testing-sample@1.0.0 test
> jest

  console.log
    Testing resources removed...

      at log (feature-integration.test.js:8:25)

 PASS  ./feature-integration.test.js
  ✓ should return an object containing a property key (3301 ms)

Test Suites: 1 passed, 1 total
Tests:       1 passed, 1 total
Snapshots:   0 total
Time:        3.578 s
Ran all test suites.

Conclusion

Integration tests allow us to uncover and fix integration bugs. It comes in handy for checking if individual units of code function together to achieve specific functionality. I've also discussed and demonstrated how to use it to test the integration of a feature flag in some JavaScript code using ConfigCat's Public Management API. If you're excited about trying this, I highly recommend signing up for a free tier ConfigCat account.

For more awesome posts and other announcements, follow ConfigCat on Twitter, Facebook, LinkedIn, and GitHub. The most lovable feature flag service, ever.

Interview with ConfigCat Engineers

Chavez Harris — Sun, 19 Nov 2023 19:22:51 +0000

As a front-end developer, I spend most of my time writing code and developing front-end applications. Several months ago, I wondered what it would be like to run a tech startup. It turns out that I spend my spare time writing blog articles for such a company. Meet ConfigCat, a thriving tech startup that offers a cloud-hosted feature flagging solution to other tech companies.

Most importantly, I was curious to know how the company was created and the secret behind its success, as well as how they are able to handle high-end user demands while delivering a seamless feature flagging solution. To answer these questions, I decided to conduct an online interview with the core engineering team to satisfy my curiosity and to share what I found with you, the reader.

But first, what is ConfigCat?

ConfigCat is an online feature flagging service that allows users to manage feature flags from a central dashboard. A feature flag is a boolean value that is linked to a feature in a software application. Most often, it is used in a conditional statement to show or hide the feature when it is true or false, respectively. This means I can control what features to show or hide in my app remotely with a few clicks without editing and redeploying my app.

The company makes available an extensive list of SDKs that allow developers to use their feature flag services in many programming languages and frameworks.

Being a front-end guy, I mainly used the JavaScript SDK in my apps. I was amazed by how seamlessly the SDK works and wanted to see what the architecture supporting these processes was like.

The architecture

Here is a diagram of ConfigCat's architecture.

It may appear as a simple diagram, but how do each of its parts work independently, and how do they interact? Here's what I've learned, and I've also incorporated some information from the respective documentation to provide a clearer explanation.

The Dashboard

The dashboard is a central user interface for creating and managing feature flags. Apart from toggling a feature flag on or off, I can also target a specific group of users based on country, email, and any custom attribute, which is a neat feature. The configurations I set in the dashboard are stored in a database for later access.

The API

ConfigCat offers a Public API for managing configurations. It allows you to do pretty much the same things as you would using the dashboard interface. But this half of the company's API is primarily used for testing and scripts. The other half of the API is responsible for serving up your feature flag values to requests coming from an SDK client installed in your app (more on this soon). To shorten and optimize the requests and response time to and from the API, ConfigCat relies on Cloudflare's CDN cache network.

The CDN (Cloudflare Edge Cache)

After taking a look at Cloudflare's documentation, I understood why using it would make sense when it comes to added security and optimized performance. Cloudflare is a large network of servers working together. The servers can process huge loads of user requests with this combined power. This allows ConfigCat to serve millions of user requests.

Here's how Cloudflare is helping ConfigCat:

Traffic Security and Filtering - Because Cloudflare functions as a reverse proxy, meaning it sits in front of ConfigCat’s public API, it can apply security rules and filter traffic. This is to counteract and protect the API from malicious and direct HTTP requests. A service like this is critical in a world where Distributed Denial of Service (DDoS) attacks are prevalent.

Caching - Cloudflare also employs a network edge cache for shortening response time by storing ConfigCat’s data in a Cloudflare data center closest to the user.

The SDKs

The SDKs are merely software packages that can be installed in a software application. They provide a connecting link between the application and ConfigCat. The SDK is then able to access the API through the Cloudflare Edge Cache to download and cache the feature flag values from the dashboard for evaluating feature flags and targeting rules.

The feature flag values are downloaded in the form of a JSON file by the installed SDK. This file is downloaded periodically based on a time interval that you can modify. When the application code queries the value of a feature flag, the SDK parses the downloaded JSON file and returns the feature flag value without uploading information about you or your users.

With the optimized power from Cloudflare's CDN, their service is capable of handling a large volume of requests. Here's a short dialect from Lali, one of the core engineers:

Our CDN infrastructure is pretty simple as we only serve small .json files. We put CloudFlare's edge cache above our CDN nodes, which can handle a huge amount of requests without any trouble. ConfigCat values your data privacy and security, so the infrastructure is set up to only query the users' feature flag configuration. However, it never exposes personal user data like email and billing information.

Optimizing for faster code releases

As a developer myself, I came to understand that the work of software development doesn't stop after the initial build. That's just the beginning. Because the company's entire operation is based on software, I was curious to know how they release new updates and bug fixes.

ConfigCat leverages the power of automated tasks that execute every time an update is made to their code base. These automated tasks all work in tandem towards the end goal of releasing the updated software to users. The overall term used to describe this is called DevOps.

Github Actions

One of the tools used as part of the DevOps process is GitHub actions. Here is an overview of how the company is using it:

When code is pushed or a new feature branch is merged, it triggers a GitHub Actions workflow configured by the engineers.

The workflow consists of individual tasks that run asynchronously, one after the other. Each task is simply an action that needs to be executed. The company's typical GitHub workflow includes tasks such as:

Code reference scanning: This is a tool developed by the team to scan the source code of an application and report on feature flag usages. It tracks where specific feature flags are used and points out the unused ones, hence avoiding the accumulation of technical debt. This tool is available to anyone; you can read more about it here.

Deploying to Cloudflare Pages: Apart from changes to the backend code, it is beneficial to interact with a live preview of the frontend changes. The company uses Cloudflare Pages to build and deploy a preview of each commit to the company's website.

Azure DevOps

Another DevOps tool that the company uses is Azure DevOps. It functions similarly to GitHub Actions. This tool monitors the repository for code updates and executes a series of tasks defined in an Azure pipeline .yml file. The difference is that it runs on Azure's DevOps platform as opposed to GitHub.

The pipeline contains tasks for scanning the source code to ensure it is securely written and free of known security vulnerabilities. It also contains tasks for running the code in a Docker container which is later deployed to the Azure cloud platform.

Now that my curiosity about the technical side was satisfied there was also the non-technical side, the soft skills of running a company. More specifically, I wanted to understand how they dealt with the challenges of running a company.

Overcoming challenges

In my experience, taking on any feat comes with challenges. Sige, a co-founder of the company, told me that together, they formed a strong and willing team, backed by mutual trust and respect, and this has paved the way for possibilities. Here's what he mentioned:

Challenges of starting and running the company

Working together and sharing responsibilities: At first, everyone on the team had different opinions. While there was an immense amount of work to be done, it was a challenge deciding who was doing what.

Technical hurdles: As a team of engineers passionate about building high-quality software, We took what we already knew to a different level. We focused on creating a scalable software infrastructure that could adapt to the growing number of users.

Accounting and legal: Scalability and software were indeed crucial, and we had to put our business caps on, learning how a company works. We shifted some of our focus toward understanding the accounting and legal aspects of running a thriving and profitable company.

The first paying customer:

"Our first customer subscribed to a paid plan came around 1-1.5 years after we started to build ConfigCat. We loved building ConfigCat but it was pretty hard to wait for the first paying customer that could 'validate' our idea of building ConfigCat." - Lali, Core Engineer at ConfigCat.

As a tech user, sometimes parts break or I need some help using a piece of tech. Now that I understand the challenges and the tech side of things, I was eager to learn how the company handles customer-related issues and general support.

Customer relations

A famous quote I found reads:

"Nobody cares how much you know until they know how much you care." - Theodore Roosevelt

To get some other perspective from others who are using ConfigCat, I looked at the company's reviews up on Capterra. From what I saw, most of them were positive. Was ConfigCat capable of providing a speedy response to users having issues using their product?

Can ConfigCat react quickly to customer support requests?

From my experience, I found that reaching out to the company's support team was easy. I was able to use the contact form on their website to fill out a message and chat directly with the developer team on Slack. If you need an almost instant reply, I would recommend using Slack. After joining their Slack community, I saw developers posting issues they encountered and receiving quick assistance from the core engineers and customer success team.

Closing thoughts

Building a feature flag service can come with challenges, but the rewards can be substantial. One of the key insights I gained from this interview (apart from the technical aspects), is the team's unwavering passion for creating an exceptional product and providing top-notch customer care.

This dedication serves as their primary motivation. From my interaction with the team, it is evident why ConfigCat has garnered a significant user base, including myself, who rely on their platform to efficiently manage and release new features. When I asked, "What would be different if ConfigCat started over?" I got the following response:

"I wouldn't change anything. I think we learned a lot of things during our journey with ConfigCat and I wouldn't want to change anything." - Lali, Core Engineer at ConfigCat

Stay up-to-date

For more posts like this and other announcements, follow ConfigCat on X, Facebook, LinkedIn, and GitHub.

How to use feature flags with AWS Lambda

Chavez Harris — Wed, 25 Oct 2023 22:34:09 +0000

One of the most important technological breakthroughs of the century has been the internet — a digital network that makes the rest of the world feel like our next-door neighbor. Within the realm of the Internet, a recent technology known as cloud computing has paved the way for software developers to rent and manage remote servers in the cloud for hosting their applications. A smaller component of this technology is called Function as a Service, abbreviated as FaaS. FaaS removes the complexity of managing a full-blown backend server, enabling developers to focus solely on writing and executing the necessary functions required to run their applications.

When FaaS and feature flags are combined, you can toggle individual functions or code blocks in those functions on or off without touching its code. Let's take a closer look.

What are feature flags?

A feature flag is a boolean value linked to a feature that enables you to toggle the feature on or off by changing its value. Feature flags can be used with many programming languages and technologies including cloud platforms like AWS Lambda. Today, I'll demonstrate how to use a feature flag to control the response of a Node.js API endpoint in AWS Lambda. Let's get started.

Before we begin, let's review the essential prerequisites you'll need:

Prerequisites

A verified AWS account
Basic Node.js and AWS knowledge

Using feature flags with AWS Lambda

AWS Lambda is described on AWS's Website as: "Run code without thinking about servers or clusters". This means, rather than setting up a full-blown backend server to handle requests from your app, you can define functions in the language or runtime of your choice to be executed via a trigger (more on this shortly).

To demonstrate how to use feature flags with AWS Lambda I'll use ConfigCat's hosted feature flag service. They offer a free tier account for experimentation, and there's no limit to the number of feature flags you can implement. ConfigCat also provides an extensive list of SDKs for easy integration.

Up and running with AWS Lambda

To make this demo fun, I'll create a music search app that returns a JSON object of songs produced by a specific artist. I'll use "Eminem" for example. To get up and running with AWS Lambda, you'll need to do the following:

Sign up for a Free Tier AWS account
In the console, click the services menu at the top left, select compute > Lambda then create a new function:

Create a new function with the following details (starting from top to bottom):

Select the first option - Author from scratch
Function name: myMusicSearchFunction
Runtime: Node.js 18.x
Architecture: x86_64
Permissions: - Leave the default option

Then click Create function.

Add a trigger for executing the function. I've selected an API Gateway trigger. As a result, when a GET request is sent to the function endpoint it will trigger the execution of the function.

If all went correctly you should be able to see the following response by sending a GET request to the endpoint generated by the trigger:

Response:

"Hello from Lambda!"

Coding the sample app

Let's change the default code to create a simple music search endpoint that returns a list of songs produced by Eminem.

If you prefer to follow along, I've included a sample Node.js app here. Feel free to clone it to your computer.

Setting up the sample app

Because my function will be executed in a node runtime environment, I've included ConfigCat's Node SDK as a dependency. With this SDK, the app will be able to access my ConfigCat dashboard and probe the feature flag value. I'll use the node-fetch package to fetch the list of songs. The package.json contains everything the app needs:

Contents of package.json:

{
  "name": "feature-flags-aws-lambda-sample",
  "type": "module",
  "version": "1.0.0",
  "description": "A companion repo for How to use feature flags with AWS Lambda",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Chavez Harris",
  "license": "ISC",
  "dependencies": {
    "configcat-node": "^9.1.1",
    "node-fetch": "^3.3.1"
  }
}

Run npm install to install the packages.
Open the index.mjs file. At the top, import the ConfigCat node and fetch package, then create the ConfigCat client using your SDK key (More on this in the next section):

import * as configcat from "configcat-node";
import fetch from "node-fetch";

let configCatClient = configcat.getClient(
  "YOUR-CONFIGCAT-SDK-KEY"
);

Below the above code block, I'll create a handler function to be executed with the following code in the body:

export const handler = async(event) => {
  // Query the value of the feature flag and assign it to a constant
  const isSearchByArtisteEnabled = await configCatClient.getValueAsync(
    "searchbyartiste",
    false
  );

  let response_message = "";

  // If the feature flag is enabled
  if (isSearchByArtisteEnabled) {
    // Fetch a list of songs by eminem
    const myData = await fetch(`https://api.deezer.com/search?q=eminem`);
    const myDataAsJson = await myData.json();
    response_message = myDataAsJson;
  } else {
    // If the feature flag is disabled
    response_message = "Sorry, this feature is not available";
  }

  // Construct and return a response
  const response = {
      statusCode: 200,
      body: JSON.stringify(response_message),
  };
  return response;
};

Using a feature flag, I will control how the API responds. When the feature flag is on, it will return the list of songs by Eminem and when it is off the response will be "Sorry, this feature is not available". To do this, I'll use ConfigCat's feature flag service.

Integrating with ConfigCat

First, you'll need to sign up for a free account.
In your dashboard, create a feature flag with the following details.

Ensure that you update the code in index.mjs with your ConfigCat SDK key and feature key.

Uploading the code to AWS

To update the code of the AWS Lambda function with the code I wrote, I'll zip all the files, including the node_modules folder, and upload it to AWS.

In the root folder, run the following command to zip all the files:

zip function.zip *

This will create a function.zip file.

On the function page, with the code tab selected, upload your function.zip file

Deploy the function.

By visiting the API endpoint in your browser, you should get the following response:

Did it work?

Head over to the ConfigCat dashboard and turn off the feature flag.
Refresh the page, and you should see:

Congrats! You did it!

Conclusion

The flexibility of feature flags lends itself to many technologies and we've explored how to use them in AWS Lambda without any difficulties.
Combining feature flags with cloud functions can unlock a world of many possibilities because you can extend your cloud functions' capabilities. ConfigCat makes it easy to integrate feature flags in many languages and frameworks.

In addition to adding feature flags, you can set up user targeting rules for releasing features to specific user groups. This is most useful when setting up and doing A/B testing. With an account, you get a generous free tier for low-volume use cases which is ideal for getting started with feature flags.

Stay connected

For more posts and other announcements, follow ConfigCat on Twitter, Facebook, LinkedIn, and GitHub. The most lovable feature flag service ever.

How to use ConfigCat's public API to conduct integration tests

Chavez Harris — Sat, 12 Aug 2023 15:23:04 +0000

Prerequisites

Have JEST installed - A testing framework for testing your JavaScript code
Have Postman installed - A platform used for testing and documenting APIs
Basic JavaScript and Testing knowledge

ConfigCat's public management API

What is integration testing?

Compared to a unit test, which only tests a single piece of code or function, an integration test involves testing multiple units to determine if they work together.

Writing an integration test

Create your public API credentials on the Public API credentials management page.
I'll create an Axios instance using the credentials. This will allow you to make requests without supplying the required headers each time. Add the following code and input your credentials in the utils/axios/axios-instance.js file.

// axios-instance.js
const axios = require('axios');

const axiosInstance = axios.create({
  baseURL: 'https://api.configcat.com/v1/',
  headers: {
    'X-CONFIGCAT-SDKKEY': 'YOUR-CONFIGCAT-SDKKEY'
  },
  auth: {
    username: 'YOUR-AUTH-USERNAME',
    password: 'YOUR-AUTH-PASSWORD'
  }
});

module.exports = axiosInstance;

Do this only to follow me. In a production environment keep your credentials secure: do not embed them directly in your code and do not share them.

In the utils/feature/feature-integration.js file, import the axiosInstance.

const axiosInstance = require('../axios/axios-instance');

After reviewing and looking at the examples in the API docs, I wrote some individual functions that set up the necessary testing resources. Add these to utils/feature/feature-integration.js:

// Create Test Product
const createTestProduct = async () => {
  const organizationId = "08da0156-fc5b-4132-88e5-1d42032078f5";
  return await axiosInstance
    .post(`organizations/${organizationId}/products`, {
      name: "Test Product",
      description: "A product for testing",
    })
    .then((response) => response.data)
    .catch((error) => {
      // throw new Error(error);
      console.log(error);
    });
};

// Create Test Environment
const createTestEnvironment = async (productId) => {
  return await axiosInstance
    .post(`products/${productId}/environments`, {
      name: "Test Environment",
      description: "An environment for testing",
    })
    .then((response) => response.data)
    .catch((error) => {
      throw new Error(error);
    });
};

// Create Test Config
const createTestConfig = async (productId) => {
  return await axiosInstance
    .post(`products/${productId}/configs`, {
      name: "Test Config",
      description: "A config for testing",
    })
    .then((response) => response.data)
    .catch((error) => {
      throw new Error(error);
    });
};

// Create Test Feature Flag
const createTestFeatureFlag = async (configId, environmentId) => {
  return await axiosInstance
    .post(`configs/${configId}/settings`, {
      hint: "A feature flag for testing",
      key: "testfeatureflag",
      name: "Test Feature Flag",
      settingType: "boolean",
      initialValues: [
        {
          environmentId: environmentId,
          value: true,
        },
      ],
    })
    .then((response) => response.data)
    .catch((error) => {
      throw new Error(error);
    });
};

I'll bundle the individual functions together in a function called setupFeatureIntegration:

async function setupFeatureIntegration() {
  try {
    const { productId } = await createTestProduct();
    const { configId } = await createTestConfig(productId);
    const { environmentId } = await createTestEnvironment(productId);
    const createTestFeatureFlagResponse = await createTestFeatureFlag(configId, environmentId);
    createTestFeatureFlagResponse.productId = productId;
    return createTestFeatureFlagResponse;
  } catch (error) {
    throw new Error(error);
  }
}

You can find the complete code here

Imagine for a moment that you have a function like this in your app that depends on a specific return value produced by the setupFeatureIntegration function:

function appFunctionThatUsesTheFeatureFlag(featureFlagKey) {
  if (featureFlagKey) {
    // I can use the feature flag key
  } else {
    // I can not use the feature flag key... handle error
  }
}

// feature-integration.test.js

const axiosInstance = require('./utils/axios/axios-instance');
const setupFeatureIntegration = require('./utils/feature/feature-integration');

// Remove Test Resources
const removeTestResources = async (productId) => {
  return await axiosInstance
    .delete(`products/${productId}`)
    .then(() => console.log("Testing resources removed..."))
    .catch((error) => {
      throw new Error(error);
    });
};


test('should return an object containing a property key', async () => { 
  const data = await setupFeatureIntegration();
  expect(data).toHaveProperty("key");
  const { productId } = data;
  await removeTestResources(productId);
 })

I'll run the test with the npm run test command, which will print the test results to the console:

chavez@Chavezs-MBP public-api-guide-integration-testing-sample % npm run test

> public-api-guide-integration-testing-sample@1.0.0 test
> jest

  console.log
    Testing resources removed...

      at log (feature-integration.test.js:8:25)

 PASS  ./feature-integration.test.js
  ✓ should return an object containing a property key (3301 ms)

Test Suites: 1 passed, 1 total
Tests:       1 passed, 1 total
Snapshots:   0 total
Time:        3.578 s
Ran all test suites.

Conclusion

For more awesome posts and other announcements, follow ConfigCat on Twitter, Facebook, LinkedIn, and GitHub. The most lovable feature flag service, ever.

How to use feature flags in GODOT Engine

Chavez Harris — Sat, 24 Jun 2023 16:17:19 +0000

According to an article published by CNET, the growth of the gaming industry is expected to increase. Due to this, new game titles are on the rise as greater demands are placed on gaming companies to remain competitive by keeping their users engaged with new features and updates. With the proper feature flagging mechanism, new features and updates can be effectively managed and released to users.

What is a Feature Flag?

Today, feature flags are known as the driving force behind feature rollouts. A feature flag is a boolean value linked to a feature. When the flag is false, the feature it controls is hidden. This brilliant yet simple mechanism can be integrated and used within many programming languages and technologies you may already be using. One of those technologies is an open source Gaming Engine called GODOT.

Pre-requisites

Visual Studio Code
Have GODOT installed
Have .NET 7.0 installed

Let's talk about GODOT

GODOT is an open-source gaming engine for developing 2D and 3D games. Compared to similar technologies like Unity and Unreal Engine, GODOT is lighter and less taxing on your hardware resources. It is the ideal choice for building simple games.

To demonstrate the usage of feature flags in this technology, I've created a sample project to help you follow along.

Setup and installation

To use the GODOT Engine, you'll need to install and set it up on your computer.

For this demo, I'll use the latest version of the GODOT Engine, version 4.0.1 - .NET.

1. Download and install GODOT. Your download will contain a zipped folder. Unzip the folder.

2. You can launch the GODOT Engine by running the application file from the extracted folder.

Using the sample app

With GODOT installed, let's look at running the sample GODOT project.

1. Clone the starter-code branch.

2. Launch the GODOT Engine, browse to the folder, and open the project.

3. If you'd like to use VS Code as your editor, you can configure it as an external editor, as shown below:

Using feature flags in GODOT

One way to integrate and use feature flags in GODOT is to use a script. You can attach the script to one of your existing nodes, and when the node loads into your scene the script will be executed. Let's look at how to do this.

1. With the project open and the Scene tab selected, create a new node by clicking the + Other Node button in the left pane.

2. Create a Sprite 2D Node. You can also create just about any node with an attached script.

3. Right-click on the node to open the context menu, and select attach script as shown below:

The above will create a new file with the name Sprite.cs in your project folder. Let's look at how we can print a message to the console based on the value of a feature flag when the node is loaded.

4. Save the scene. Scene -> Save Scene.

Setting up a feature flag

ConfigCat offers a cloud-based solution for creating and managing feature flags. Let's use it to add a feature flag to use in GODOT.

1. To sign up for a ConfigCat account, click here.

2. In the Dashboard, create a feature flag with the following details:

Connecting GODOT to ConfigCat

To connect the GODOT script to ConfigCat for querying the status of the flag, we'll need to download a client SDK. Because our GODOT app uses C#, we can download and integrate ConfigCat's .NET client SDK.

1. To install the SDK into our project, we'll first need to download and install Microsoft's .NET 7.0 SDK.

2. After the installation completes, double-check that dotnet is installed by running this command:

dotnet --info

3. Launch a terminal window in the project folder, and run the following command to install the ConfigCat .NET client SDK:

dotnet add package ConfigCat.Client

4. Open the Sprite.cs file in the project folder. At the top of the file, add the following line:

using ConfigCat.Client;

5. Let's create a Ready() method to execute when the node enters the scene. In the body of the class, add the following code:

public partial class Sprite : Sprite2D
{
    // Initialize ConfigCat client
    private IConfigCatClient configCatClient = ConfigCatClient.Get("YOUR_CONFIGCAT_SDK_KEY");

    private bool isMyGodotFeatureFlag;

    public override void _Ready()
    {

      isMyGodotFeatureFlag = configCatClient.GetValue("mygodotfeatureflag", false);

      if(isMyGodotFeatureFlag) {
        GD.Print("Your feature flag is enabled!!");
      } else {
        GD.Print("Your feature flag is disabled!!");
      }

    }
}

If you build and run the project by clicking the "Play" icon button at the top right, you should see the sprite node icon displayed in the window and the following message logged to your console:

Let's take it a step further and make the note rotate when the feature flag is enabled. To do this, modify the Sprite class as follows:

public partial class Sprite : Sprite2D
{
  private int speed = 400;
  private int AngularSpeed = (int)Mathf.Pi;

  // Initialize ConfigCat client
  private IConfigCatClient configCatClient = ConfigCatClient.Get("YOUR_CONFIGCAT_SDK_KEY");

  private bool isRotateSpriteEnabled;

  public override void _Ready()
  {
    isRotateSpriteEnabled = configCatClient.GetValue("mygodotfeatureflag", false);

    if (isRotateSpriteEnabled)
    {
      GD.Print("Your feature flag is enabled!!");
    }
    else
    {
      GD.Print("Your feature flag is disabled!!");
    }


  }

  public override void _Process(double delta)
  {
    if (isRotateSpriteEnabled)
    {
      Rotation += AngularSpeed * (float)delta;
    }
  }
}

You can view the complete Sprite.cs file here.

6. If you run the project again, and the feature flag is enabled, the sprite node will rotate:

Code

Feel free to check out the completed GODOT project here.

Final thoughts

The flexible nature of feature flagging lends itself to many software technologies, and game development engines are no exception. You've seen how simple it is to add a feature flag to GODOT, and we've only scratched the surface of what is possible with feature flagging. With a feature flagging solution, you can enhance canary deployments, A/B testing, and software updates. One of the most sought-after benefits of flagging features is that you can switch them on and off remotely without touching your code.

ConfigCat also supports many other frameworks and languages. Check out the entire list of supported SDKs here.

For more awesome content, keep up with ConfigCat on Twitter, Facebook, LinkedIn, and GitHub.

How to use ConfigCat with Redis

Chavez Harris — Wed, 07 Jun 2023 19:51:18 +0000

Ever since the dawn of feature releases, feature flags have become the de facto standard for managing and controlling features in software applications. Many software development methodologies these days such as agile, are heavily focused on releasing continuous updates and features. In addition, a few companies have based their entire business around serving clients a cloud-based feature flagging solution. But in limited bandwidth situations or when you need to optimize the performance of your client-facing applications making API requests may not be ideal. This can be handled by implementing a process called caching with the help of a popular tool called Redis.

What are feature flags?

A feature flag can be described as a light switch for features. It holds a boolean value, that when set to true, the feature it controls can be displayed to the user and otherwise hidden.

The awesome thing about feature flagging is that it can be applied to a wide range of programming languages and frameworks. And because of its flexible nature, it can be used alongside other technologies. Let's look at how it can be implemented with a Redis cache to see how it works.

Pre-requisites

A code editor (e.g. Visual Studio Code)
NodeJS (version 16 or higher)
Basic Node.js and Redis knowledge.
Have Docker installed on your computer.

To help you follow through with me, I've created a Node.js sample app that you can clone from the following link. Later on, we'll cover how to set it up.

Adding a feature flag

1. To get started, sign up for a free ConfigCat account.

2. In your dashboard, create a feature flag with the following information:

Creating the Redis cache client

3. From the starter-code branch, open the file called configcat-redis-cache.js and add the following functions:

// ...

function configcatRedisCache(redisClientOptions) {

  this.isRedisAvailable = false;
  this.cacheClient = redis.createClient(redisClientOptions);

  this.cacheClient.connect();

  this.cacheClient.on("connect", () => {
    console.log("Connected to Redis");
    this.isRedisAvailable = true;
  });

  this.cacheClient.on("error", (error) => {
    console.log(`Redis error: ${error}`);
    this.isRedisAvailable = false;
  });

  this.lastCacheItems = {};
}

configcatRedisCache.prototype.get = async function (key) {
  if (!this.isRedisAvailable) {
    return this.lastCacheItems[key];
  }

  try {
    const getAsync = util
      .promisify(this.cacheClient.get)
      .bind(this.cacheClient);

    return JSON.parse(await getAsync(key));
  } catch (error) {
    console.error(`Cache read failed! \n ${error}`);
    return this.lastCacheItems[key];
  }
};

configcatRedisCache.prototype.set = async function (key, item) {
  this.lastCacheItems[key] = item;

  try {
    const setAsync = util
      .promisify(this.cacheClient.set)
      .bind(this.cacheClient);

    await setAsync(key, JSON.stringify(item));
  } catch (error) {
    console.error(`Cache write failed! \n ${error}`);
  }
};

// ...

Here's what each function does:

configcatRedisCache - Takes the client options as its parameter and sets up a connection to the docker Redis instance.
configcatRedisCache.prototype.get - Uses the provided key to obtain the cached item from Redis.
configcatRedisCache.prototype.set - Takes the key and item as parameters. Puts the item into the redis cache that can be later accessed using the key.

4. Open the index.js file and add the following code:

// ...
const redisOptions = { host: "localhost", port: 6379 };

const configCatClient = configcat.getClient("0yDbCLmNK0qIUakB2LFJDA/u0Z5j4oDjkuHKOVJkIo9Dw", configcat.PollingMode.AutoPoll, 
  {
    cache: configcatRedisCache(redisOptions)
  }
);

setInterval(() => {
  configCatClient.getValueAsync("isMyAwesomeFeatureEnabled", false).then(value => {
    console.log(`${new Date().toTimeString()} isMyAwesomeFeatureEnabled: ${value}`);
  });
}, 5000);

Here's what the code is doing:

The configuration required to establish a connection to the Redis docker instance was saved to the redisOptions variable.
That variable was then used in the configcat.getClient method passed as an argument to set up the cache property.
The setInterval function runs every 5 seconds to fetch the value of the feature flag, but instead of reaching out to ConfigCat, it obtains the value from the Redis cache and logs the result with the date to the console.

You can find the complete code for the index.js file here. If you're curious about learning more about using a custom cache with ConfigCat as we did, refer to this documentation.

With the code in place, let's look at how we can run the sample app to ensure it works.

Running the sample app

1. Clone the GitHub repository

2. Run the following commands to install the required node packages:

npm install

The configcat-node and redis npm packages will also be installed using this command. The configcat-node package will be used as a client to connect to and pull the feature flag status from your ConfigCat dashboard. redis will be used similarly and would connect to a local docker instance of Redis.

3. Using docker, pull the latest Redis docker image and run the container:

docker pull redis

docker run --name container-redis -p 6379:6379 -d redis

4. Start the node application with the following command:

npm start

You should see the following output logged to your terminal every 5 seconds:

> configcat-with-redis-sample@1.0.0 start
> node index.js

Connected to Redis
17:56:55 GMT-0300 (French Guiana Time) isMyAwesomeFeatureEnabled: false
17:57:00 GMT-0300 (French Guiana Time) isMyAwesomeFeatureEnabled: false
17:57:05 GMT-0300 (French Guiana Time) isMyAwesomeFeatureEnabled: false
17:57:10 GMT-0300 (French Guiana Time) isMyAwesomeFeatureEnabled: false
17:57:15 GMT-0300 (French Guiana Time) isMyAwesomeFeatureEnabled: false
17:57:20 GMT-0300 (French Guiana Time) isMyAwesomeFeatureEnabled: false

Toggling on or off the feature flag within your ConfigCat dashboard will force the cache to refresh. As a result, The new value will be pulled from ConfigCat to replace the existing value in the cache.

Final thoughts

If you're planning on cutting back or saving bandwidth utilization and optimizing for better performance on the client side then a caching solution like Redis can help. And, as we've seen from the code examples, Redis integrates quite easily with ConfigCat. With a caching solution in place, you can supercharge the way you do standard feature releases, canary deployments, and A/B testing. Besides Node.js, ConfigCat also supports many languages and frameworks and provides SDKs for easy configuration.

Stay updated

For more posts like this and other announcements, follow ConfigCat on Twitter, Facebook, LinkedIn, and GitHub.

Automating and managing your ConfigCat resources with Terraform

Chavez Harris — Sun, 04 Jun 2023 13:53:42 +0000

It can be time-consuming to create and manage the infrastructure that drives your software applications as they grow and become larger. Also, what about ongoing updates and releases of new features? Luckily, there is a solution to this problem in the form of a tool designed by Hashicorp called Terraform. This allows us to define our infrastructure in a central configuration file without having to create it on every provider platform we use.

What is Terraform?

Terraform is a popular Infrastructure as Code tool that allows you to automate and manage your infrastructure by defining how it should be in an easy-to-read configuration file.

Upon executing the file, Terraform does the heavy lifting for you (that you would have otherwise had to do manually) by connecting to your cloud providers of choice to provision your infrastructure on the fly. By also keeping track of the state of your infrastructure changes along the way, Terraform can figure out what parts of your infrastructure have remained the same from what has changed and only executes those changes.

Using ConfigCat with Terraform

In addition to being the go-to choice for many companies managing their infrastructure as code, Terraform can also be ideal for managing and provisioning your ConfigCat resources programmatically. Using the ConfigCat Feature Flags Provider for Terraform, you can gain the same level of control and management over these resources similarly as you do with your other infrastructure components.

Here are some reasons why you might want to consider using ConfigCat and Terraform together for your next infrastructure build:

Supports a multienvironment setup - If your company already has multiple environments like test, staging, and production for other elements of their infrastructure you can define a similar setup using the ConfigCat provider in your Terraform config file.
Best for managing multiple products - Even though the ConfigCat dashboard is easy and intuitive to navigate, you can often lose track of all your products and their respective configurations. It would be better to define them with Terraform. With this approach, you can prevent overlapping and duplications to ensure that your resources are used efficiently with less clutter.
Collaboration, and centralized infrastructure management - Terraform scripts usually live in a git repository, making it ideal for managing your ConfigCat resources in a central place. With the added benefit of git operations, you can perform actions such as branching, pull requests and approve strategy.

For example - Suppose you were tasked with creating a new environment in ConfigCat. You can either do it manually without supervision or you can open a pull request with your modified Terraform
scripts and that pull request can be approved. This way you have strict control over who can create resources and or what resources are created.

Live Demo

Let's examine an example of how you can use Terraform to set up a feature flag resource from scratch.

To get started, check that you have Terraform installed and configured on your computer. It is also quite handy to install the Terraform VS Code extension for Terraform if you’re using the VS Code Editor to follow along.

The sample ConfigCat infrastructure that we're about to set up will include the following:

An Organization - Because organizations can contain specific information about a company or individual's billing makes them read-only from Terraform. It is recommended that you first create an empty organization in your ConfigCat dashboard.
A Product - Represents your application, and includes your Configs, Environments, and Team members.
An Environment - Represents the environment in your development lifecycle like production, staging, development, etc.
A Feature flag - A feature toggle (boolean value) that you can turn on or off to enable or disable a feature.

Finding your credentials

To grant Terraform access to your ConfigCat account you’ll need to create your ConfigCat public API credentials here.

Integrating with Terraform

With a blank folder opened in your code editor, create two files: variables.tf and main.tf.
In the variables.tf file, add the credentials you created:

variable "configcat_basic_auth_username" {
  type = string
  default = "INPUT_YOUR_AUTH_USERNAME_HERE"
}

variable "configcat_basic_auth_password" {
  type = string
  default = "INPUT_YOUR_AUTH_PASSWORD_HERE"
}

In the main.ts file:

a. Define the ConfigCat provider along with your credentials:

terraform {
  required_providers {
    configcat = {
      source = "configcat/configcat",
      version = "~> 1.0"
    }
  }
}

provider "configcat" {
  basic_auth_username = var.configcat_basic_auth_username
  basic_auth_password = var.configcat_basic_auth_password
}

b. Define the following resources to be created:

data "configcat_organizations" "my_organizations" {

}
resource "configcat_product" "my_product" {
  organization_id = data.configcat_organizations.my_organizations.organizations.0.organization_id
  name = "My product"
  description = "My example product"
}

resource "configcat_environment" "my_environment" {
  product_id = configcat_product.my_product.id
  name = "Production"
  description = "The production environment"
  color = "blue"
}

resource "configcat_config" "my_config" {
  product_id = configcat_product.my_product.id
  name = "My config"
  description = "My example config"
}

resource "configcat_setting" "is_awesome" {
  config_id = configcat_config.my_config.id
  key = "isMyAwesomeFeatureEnabled"
  name = "My awesome feature flag"
  hint = "this is the hint for my awesome feature flag"
  setting_type = "boolean"
}

Execute this with Terraform using the plan and apply commands respectively, and within a few seconds, you should see the specified resources created in your Dashboard.

Final thoughts

Terraform takes care of what has to be created, updated, and destroyed based on changes you make to your Terraform config file. Using it with ConfigCat has its proven benefits as we discussed earlier. In my opinion, it supercharges your development, feature releases, and canary deployment workflows while giving you high-level and automated management over your current infrastructure within a simple .tf config file.

Why not give it a go? Sign up for a free-tier ConfigCat account here and stay on top of the latest posts and announcements from ConfigCat on Twitter, Facebook, LinkedIn, and GitHub.

Forem: Chavez Harris

Using Feature Flags with Machine Learning Models

Using feature flags with machine learning models

Guide: How to use feature flags with machine learning models

Setup of a demo application

Adding a feature flag

Running the app

Prerequisites

Steps

Did it work

The future of feature flags and machine learning models

Using ConfigCat for Staged Rollouts and Canary Releases

What are staged rollouts and canary releases

The role of ConfigCat in staged rollouts and canary releases

Performing a canary release with ConfigCat

Best practices for using ConfigCat for staged rollouts and canary releases

Has ConfigCat proven itself in the real world?

Conclusion

Feature Flag Services Under $300

Companies that stood out to me

Signing up

Signing up for ConfigCat

Signing up for Azure App Configuration

Signing up for LaunchDarkly

Pricing

ConfigCat

Azure App Configuration

Launch darkly

Ease of use

UX: ConfigCat

UX: Azure App Configuration

UX: LaunchDarkly

Permission and team management

ConfigCat

Azure App Configuration

LaunchDarkly

Enterprise-level features

Authentication

Support and Team

ConfigCat

Microsoft App configuration

LaunchDarkly

Final thoughts

Skipping Test Environments for Faster and Safer Deployments

Definition and purpose of test environments

Challenges and limitations of test environments

Higher cost

Complexity

Coverage

Testing in production with feature flags

Faster feedback

Higher quality

Lower risk

Companies testing in production

Kantan.tech moves faster than their competition

Eucalyptus growth is improved

Conclusion

How to Use ConfigCat Feature Flags with Docker

Introducing Feature Flags

ConfigCat: A Cloud-Hosted Feature Flag Provider

How to Use ConfigCat Feature Flags with Docker

Developing a Docker Desktop Extension

Test Drive

Best Practices to Consider When Using ConfigCat Feature Flags with Docker

Developing Your Docker Extensions with Feature Flags in Mind

Optimizing for Faster Performance

Summary of Key Points

Conclusion

References

Source Code

Further Reading

How to use ConfigCat's public API to conduct integration tests

Prerequisites

ConfigCat's public management API

What is integration testing?

Writing an integration test

Conclusion

Interview with ConfigCat Engineers

But first, what is ConfigCat?

The architecture