feature-flags | A dynamic feature flags library for Node.js | Access Management library

It seems to be a different version of amplify cli between the aws build image and your machine.

Check your version of amplify cli :

It looks like these warnings are generated when there are no global variables named __VUE_OPTIONS_API__ and __VUE_PROD_DEVTOOLS__ (see code).

In a webpack setup, you can inject global variables at build time with the Define Plugin. Unfortunately, I'm not aware of any parcel2 plugin (yet) that does this (although it would be pretty simple to write). However, you could just create them yourself by writing this near the beginning of your app's entry .js file:

the comment suggestion from Benjamin Brootz worked. So here's the solution:

A simple combination of curl which downloads the file and pipes it into sed, which substitutes the stable to alpha works like a charm - especially since this flag is the only line including stable (except of the commentary line directly above). sed is a common tool to set dynamic values with Kubernetes yaml file.

You may test-drive it adding a grep at the end to see the lines changed with:

The typical approach to mounting files into a CloudFoundry application is called Volume Services. This takes a remote file system like NFS or SMB and mounts it into your application container.

I don't think that's what you want here. It would probably be overkill to mount in a single file. You totally could go this route though.

That said, CloudFoundry does not have a built-in concept that's similar to Kubernetes, where you can take your configuration and mount it as a file. With CloudFoundry, you do have a few similar options. They are not exactly the same though so you'll have to make the determination if one will work for your needs.

1. You can pass config through environment variables (or through user-provided service bindings, but that comes through an environment variable VCAP_SERVICES as well). This won't be a file, but perhaps you can have your UI read that instead (You didn't mention how the UI gets that file, so I can't comment further. If you elaborate on that point like if it's HTTP or reading from disk, I could perhaps expand on this option).

   If it absolutely needs to be a file, your application could read the environment variable contents and write it to disk when it starts. If your application isn't able to do that like if you're using Nginx, you could include a .profile script at the root of your application that reads it and generates the file. For example: echo "$CFG_VAR" > /dist/file or whatever you need to do to generate that file.

   A couple of more notes when using environment variables. There are limits to how much information can go in them (sorry I don't know the exact value off the top of my head, but I think it's around 128K). It is also not great for binary configuration, in which case, you'd need to base64 encode your data first.

2. You can pull the config file from a config server and cache it locally. This can be pretty simple. The first thing your app does when it starts is to reach out and download the file, place it on the disk and the file will persist there for the duration of your application's lifetime.

   If you don't have a server-side application like if you're running Nginx, you can include a .profile script (can be any executable script) at the root of your application which can use curl or another tool to download and set up that configuration.

   You can replace "config server" with an HTTP server, Git repository, Vault server, CredHub, database, or really any place you can durably store your data.

3. Not recommended, but you can also push your configuration file with the application. This would be as simple as including it in the directory or archive that you push. This has the obvious downside of coupling your configuration to the application bits that you push. Depending on where you work, the policies you have to follow, and the tools you use this may or may not matter.

There might be other variations you could use as well. Loading the file in your application when it starts or through a .profile script is very flexible.

Azure App Configuration helps to manage application settings and control their access centrally. It’s built on the simple concept of key-value pairs, and this service provides manageability, availability, and ease-of-use.

To solve the problem you are facing please check if you are using the right library and also check if you are having the following NuGet packages from Microsoft to work with an Azure App Configuration resource and the ability to use Feature Flags in the project.

Microsoft.Azure.AppConfiguration.AspNetCore Microsoft.Extensions.Configuration.AzureAppConfiguration Microsoft.FeatureManagement

As you have added FeatureManagement by using statement in Startup.cs and inside of ConfigureServices(...) added the ability to use it. Check if have modified the Program.cs and replaced the creation of default host builder with one that uses Azure App Configuration as shown below.

The issue was solved by bumping storybook to the latest stable version aka 4.1.0 as shown here: https://github.com/nuxt-community/storybook/releases

Nuxt was pretty much the latest already.

FeatureGateAttribute is an API for ASP.NET Core applications. It's not included in the base feature management package (Microsoft.FeatureManagement). You need to install the Microsoft.FeatureManagement.AspNetCore package.

Instructions can be found at https://docs.microsoft.com/en-us/azure/azure-app-configuration/quickstart-feature-flag-aspnet-core?tabs=core5x#connect-to-an-app-configuration-store

Yeah your first option is the best one. Most readable.