go feature flag
v1.40.0
Se você estiver usando o sinalizador de recursos Go, considere se adicionar na lista de adotantes.
Esse ato simples aumenta significativamente a visibilidade e credibilidade do projeto, fazendo uma contribuição substancial ao seu avanço.Se você quiser me apoiar e ir à bandeira, também pode se tornar um patrocinador.
O Sinalizador de Recursos GO é uma solução leve e de código aberto que fornece uma implementação de sinalizador simples e completa de recursos.
A solução foi criada para facilitar o uso de sinalizadores de recursos em seu código com a configuração mais fácil possível.
Originalmente, o sinalizador de recursos Go foi projetado como uma solução exclusivamente para o idioma GO . Com a nova padronização dos sinalizadores de recursos pelo projeto OpenFeature, a solução está agora disponível para vários idiomas (lista de linguagens suportadas) por meio de um servidor de API simples chamado Proxy de relé, que pode ser hospedado.
Dica
Se você não está familiarizado com os sinalizadores de recursos, escrevi um artigo que explica por que os sinalizadores de recursos podem prender seu ciclo de iteração.
HTTP , S3 , Kubernetes , consulte a lista completa ).JSON , TOML e YAML ).S3 , Google cloud storage , file , consulte a lista completa ) .webhook e slack ) . O código desta demonstração está disponível em examples/demo .
Importante
Antes de começar a usar o sinalizador de recursos Go, você deve decidir se deseja usar os SDKs do recurso aberto ou se deseja usar o sinalizador de recursos Go como um módulo Go.
Recomendamos o uso do proxy de relé para uma solução central de gerenciamento e avaliação de sinalizadores, ele permite o suporte a várias linguagens e se integra perfeitamente ao SDKS de recurso aberto.
Esta é a melhor maneira de obter o sinalizador de recursos do Go Potendent of Go.
Se o seu projeto estiver exclusivamente em Go, o módulo GO é uma opção. Ele executará a avaliação do sinalizador diretamente no seu código GO.
Crie um novo arquivo YAML contendo sua primeira configuração de sinalizador.
# 20% of the users will use the variation "my-new-feature"
test-flag :
variations :
my-new-feature : true
my-old-feature : false
defaultRule :
percentage :
my-new-feature : 20
my-old-feature : 80 Essa bandeira dividiu o uso dessa bandeira, 20% usará a variação my-new-feature e 80% a variação my-old-feature .
Crie um novo arquivo YAML contendo a configuração do seu proxy de relé.
listen : 1031
pollingInterval : 1000
startWithRetrieverError : false
retriever :
kind : file
path : /goff/flag-config.yaml
exporter :
kind : log E executaremos o proxy do relé localmente para disponibilizar a API.
A porta padrão será 1031 .
# Launch the container
docker run
-p 1031:1031
-v $( pwd ) /flag-config.yaml:/goff/flag-config.yaml
-v $( pwd ) /goff-proxy.yaml:/goff/goff-proxy.yaml
gofeatureflag/go-feature-flag:latest
Se você não quiser usar o Docker para instalar o proxy do relé, poderá seguir outras maneiras de instalá -lo na documentação.
Neste exemplo, estamos usando o NodeJS SDK , mas você pode verificar outros idiomas aqui.
npm i @openfeature/server-sdk @openfeature/go-feature-flag-providerNa inicialização do seu aplicativo, você deve criar um cliente usando o recurso aberto SDK e inicializá -lo.
const { OpenFeature } = require ( "@openfeature/server-sdk" ) ;
const { GoFeatureFlagProvider } = require ( "@openfeature/go-feature-flag-provider" ) ;
// init Open Feature SDK with GO Feature Flag provider
const goFeatureFlagProvider = new GoFeatureFlagProvider ( {
endpoint : 'http://localhost:1031/' // DNS of your instance of relay proxy
} ) ;
OpenFeature . setProvider ( goFeatureFlagProvider ) ;
const featureFlagClient = OpenFeature . getClient ( 'my-app' ) Agora você pode avaliar seus sinalizadores em qualquer lugar do seu código usando este cliente.
// Context of your flag evaluation.
// With GO Feature Flag you MUST provide a targetingKey that is a unique identifier of the user.
const evaluationContext = {
targetingKey : '1d1b9238-2591-4a47-94cf-d2bc080892f1' , // user unique identifier (mandatory)
firstname : 'john' ,
lastname : 'doe' ,
email : '[email protected]' ,
admin : true , // this field is used in the targeting rule of the flag "flag-only-for-admin"
// ...
} ;
const adminFlag = await featureFlagClient . getBooleanValue ( 'flag-only-for-admin' , false , evaluationContext ) ;
if ( adminFlag ) {
// flag "flag-only-for-admin" is true for the user
console . log ( "new feature" ) ;
} else {
// flag "flag-only-for-admin" is false for the user
}go get github.com/thomaspoignant/go-feature-flag Crie um novo arquivo YAML contendo sua primeira configuração de sinalizador.
# 20% of the users will use the variation "my-new-feature"
test-flag :
variations :
my-new-feature : true
my-old-feature : false
defaultRule :
percentage :
my-new-feature : 20
my-old-feature : 80 Essa bandeira dividiu o uso dessa bandeira, 20% usará a variação my-new-feature e 80% a variação my-old-feature .
Primeiro, você precisa inicializar o ffclient com a localização do seu arquivo de back -end.
err := ffclient . Init (ffclient. Config {
PollingInterval : 3 * time . Second ,
Retriever : & fileretriever. Retriever {
Path : "flag-config.goff.yaml" ,
},
})
defer ffclient . Close ()Este exemplo carregará um arquivo do seu computador local e atualizará os sinalizadores a cada 3 segundos (se você omitir o PollingInterval, o valor padrão será de 60 segundos).
ℹ Informações
Esta é uma configuração básica para testar localmente; na produção, é melhor usar um local remoto para armazenar o arquivo de configuração do sinalizador de recursos.
Observe a lista de opções disponíveis na página do arquivo de sinalizador da loja .
Agora você pode avaliar suas bandeiras em qualquer lugar do seu código.
user := ffcontext . NewEvaluationContext ( "user-unique-key" )
hasFlag , _ := ffclient . BoolVariation ( "test-flag" , user , false )
if hasFlag {
// flag "test-flag" is true for the user
} else {
// flag "test-flag" is false for the user
} A documentação completa está disponível em https://docs.gofeatureflag.org
Você pode encontrar mais exemplos nos exemplos/ diretório.
Originalmente, o sinalizador de recursos Go foi construído para ser apenas uma biblioteca Golang, mas limita demais o ecossistema.
Para ser compatível com mais idiomas, implementamos o proxy do relé do sinalizador GO. É um serviço que você pode hospedar que fornece uma API para avaliar suas bandeiras, você pode chamá -lo usando o HTTP para obter sua variação.
Como acreditamos na padronização, também estamos implementando provedores de abertura aberta para interagir com essa API no idioma de sua escolha.
(OpenFeature ainda está em um estágio inicial; portanto, nem todos os idiomas são suportados e esperam algumas mudanças no futuro)
Por enquanto, temos provedores para:
| Linguagem | Fonte de provedor | Versão |
|---|---|---|
| Ir | Provedor Go | |
| Java / Kotlin (servidor) | Provedor de Java | |
| Android / Kotlin (cliente) | Provedor de Kotlin | |
| JavaScript/TypeScript (servidor) | Provedor de servidor | |
| JavaScript/TypeScript (cliente) | Provedor de clientes | |
| Python | Provedor de Python | |
| .Líquido | .NET provedor | |
| Rubi | Provedor de rubi | |
| Swift | Provedor Swift | |
| Php | Provedor de PHP |
O módulo suporta diferentes maneiras de recuperar o arquivo de sinalizador.
Os Retrievers disponíveis são:
Veja a lista completa e mais informações.
O recurso GO RECURSO FAGN CORE é centralizar todos os sinalizadores de seus recursos em um único arquivo e evitar hospedagem e manutenção de um servidor de back -end para gerenciá -los.
Seu arquivo deve ser um arquivo YAML , JSON ou TOML com uma lista de sinalizadores (exemplos: YAML , JSON , TOML ) .
A maneira mais fácil de criar seu arquivo de configuração é usar o editor de sinalizadores Go Feature disponível em https://editor.gofeatureflag.org.
Se você preferir fazê -lo manualmente, siga as instruções abaixo.
Uma configuração de bandeira se parece com a seguinte:
# This is your configuration for your first flag
first-flag :
variations : # All possible return value for your feature flag
A : false
B : true
targeting : # If you want to target a subset of your users in particular
- query : key eq "random-key"
percentage :
A : 0
B : 100
defaultRule : # When no targeting match we use the defaultRule
variation : A
# A second example of a flag configuration
second-flag :
variations :
A : " valueA "
B : " valueB "
defaultValue : " a default value "
targeting :
- name : notkey_rule
query : key eq "not-a-key"
percentage :
A : 10
B : 90
defaultRule :
variation : defaultValue
version : " 12 "
experimentation :
start : 2021-03-20T00:00:00.1-05:00
end : 2021-03-21T00:00:00.1-05:00{
"first-flag" : {
"variations" : {
"A" : false ,
"B" : true
},
"targeting" : [
{
"query" : " key eq " random-key " " ,
"percentage" : {
"A" : 0 ,
"B" : 100
}
}
],
"defaultRule" : {
"variation" : " A "
}
},
"second-flag" : {
"variations" : {
"A" : " valueA " ,
"B" : " valueB " ,
"defaultValue" : " a default value "
},
"targeting" : [
{
"name" : " notkey_rule " ,
"query" : " key eq " not-a-key " " ,
"percentage" : {
"A" : 10 ,
"B" : 90
}
}
],
"defaultRule" : {
"variation" : " defaultValue "
},
"version" : " 12 " ,
"experimentation" : {
"start" : " 2021-03-20T05:00:00.100Z " ,
"end" : " 2021-03-21T05:00:00.100Z "
}
}
}[ first-flag . variations ]
A = false
B = true
[[ first-flag . targeting ]]
query = ' key eq "random-key" '
[ first-flag . targeting . percentage ]
A = 0
B = 100
[ first-flag . defaultRule ]
variation = " A "
[ second-flag ]
version = " 12 "
[ second-flag . variations ]
A = " valueA "
B = " valueB "
defaultValue = " a default value "
[[ second-flag . targeting ]]
name = " notkey_rule "
query = ' key eq "not-a-key" '
[ second-flag . targeting . percentage ]
A = 10
B = 90
[ second-flag . defaultRule ]
variation = " defaultValue "
[ second-flag . experimentation ]
start = 2021-03-20T05:00:00.100Z
end = 2021-03-21T05:00:00.100ZPara obter informações detalhadas sobre os campos necessários para criar um sinalizador, consulte a documentação.
O formato de consulta é baseado na biblioteca nikunjy/rules .
Todas as operações podem ser escritas em capitalizadas ou minúsculas (ex: eq ou EQ podem ser usadas).
As operações lógicas suportadas são AND OR .
Compare a expressão e suas definições ( a|b significa que você pode usar um dos dois a ou b ):
eq|==: equals to
ne|!=: not equals to
lt|<: less than
gt|>: greater than
le|<=: less than equal to
ge|>=: greater than equal to
co: contains
sw: starts with
ew: ends with
in: in a list
pr: present
not: not of a logical expression
key eq "[email protected]"anonymous ne trueuserId eq "12345" Um contexto de avaliação em um sistema de sinalização de recursos é crucial para determinar a saída de uma avaliação do sinalizador de recursos. É uma coleção de dados pertinentes sobre as condições sob as quais a avaliação está sendo feita. Esses dados podem ser fornecidos através de uma mistura de informações estáticas (nome do servidor, IP, etc ...) e entradas dinâmicas (informações sobre o usuário que executam a ação, etc ...), juntamente com as informações de estado que são transportadas implicitamente através da execução do programa.
Ao usar o sinalizador de recursos Go, geralmente é necessário personalizar a experiência para diferentes usuários. É aqui que o conceito de chave de segmentação entra em jogo. Uma chave de segmentação é um identificador exclusivo que representa o contexto da avaliação (email, ID da sessão, uma impressão digital ou qualquer coisa que seja consistente) , garantindo que eles sejam consistentemente expostos à mesma variação de um recurso, mesmo em várias visitas ou sessões.
Por exemplo, o sinalizador de recursos Go garante que, nos casos em que um recurso esteja sendo lançado para uma porcentagem de usuários, com base na chave de segmentação, eles verão a mesma variação cada vez que encontrarem o sinalizador de recursos.
A chave de segmentação é uma parte fundamental do contexto de avaliação, pois afeta diretamente a determinação de qual variante de recurso é servida a um usuário em particular e mantém essa continuidade ao longo do tempo. Para fazer isso, vá com o sinalizador para fazer um hash para definir se o sinalizador puder se aplicar a esse contexto de avaliação ou não.
Recomendamos usar um hash, se possível.
A segmentação de sinalizadores e os lançamentos de recursos são determinados pelo usuário que você passa para suas chamadas de avaliação.
Em alguns casos, pode ser necessário usar usuários de balde com base em uma chave diferente, por exemplo, um teamId , para que os usuários da mesma equipe sejam expostos à mesma variação de bandeira e obtenham uma experiência consistente.
Isso pode ser conseguido definindo o campo bucketingKey na configuração do sinalizador. Quando presente, o valor correspondente ao bucketingKey será extraído dos atributos e esse valor usado para hash e determinar o resultado no lugar do targetingKey .
As variações são os diferentes valores possíveis para um sinalizador de recursos.
O sinalizador de recursos Go pode gerenciar mais do que apenas valores boolean ; O valor da sua bandeira pode ser qualquer um dos seguintes tipos:
boolintfloatstringjson arrayjson object Boolean result = featureFlagClient . getBooleanValue ( "your.feature.key" , false , userContext );
// this example is using the java SDK
// result is now true or false depending on the setting of this boolean feature flagOs métodos de variação pegam a chave do sinalizador de recursos, um contexto de avaliação e um valor padrão .
Por que precisamos de um valor padrão? Se tivermos algum erro durante a avaliação do sinalizador, retornaremos o valor padrão, você sempre obterá um retorno de valor da função e nunca lançaremos um erro.
No exemplo, se o sinalizador your.feature.key não existir, o resultado será false .
Observe que o resultado sempre fornecerá um valor utilizável.
Uma parte crítica de cada novo lançamento de recursos é orquestrar o cronograma de lançamento real entre as equipes de produtos, engenharia e marketing.
O fornecimento de experiências poderosas ao usuário normalmente exige que as equipes de software gerenciem versões complexas e façam atualizações manuais em momentos inconvenientes.
Mas não precisa, ter uma estratégia de lançamento complexa permite que você tenha um ciclo de vida para suas bandeiras.
Se você quiser ser informado quando um sinalizador tiver alterado, pode configurar um notificador .
Um notificador enviará uma notificação ao sistema direcionado para informá -los de que uma nova configuração de sinalizador foi carregada.
O sinalizador de recursos Go pode lidar com mais de um notificador de cada vez.
Os notificadores disponíveis são:
O sinalizador de recursos Go permite exportar dados sobre o uso de suas bandeiras.
Ele coleta todos os eventos de variação e pode salvar esses eventos em vários locais:
Atualmente, estamos apoiando apenas eventos de recursos.
Representa avaliações de sinalizadores individuais e é considerado eventos de "fidelidade total".
Um exemplo de evento de recurso abaixo:
{
"kind" : " feature " ,
"contextKind" : " anonymousUser " ,
"userKey" : " ABCD " ,
"creationDate" : 1618228297 ,
"key" : " test-flag " ,
"variation" : " Default " ,
"value" : false ,
"default" : false ,
"source" : " SERVER "
}O formato dos dados é descrito na documentação. Os eventos são coletados e enviados a granel para evitar spam para o seu exportador.
Uma ferramenta de linha de comando está disponível para ajudá-lo a lint seu arquivo de configuração: ir-flag-lint.
Este projeto recebe contribuições da comunidade. Se você estiver interessado em contribuir, consulte o guia dos colaboradores para obter algumas dicas úteis.
Como a voz de todos é importante, queremos ouvir a comunidade.
Por esse motivo, estamos lançando uma reunião da comunidade a cada 2 semanas e é o local perfeito para discutir o Future of Go Feature Flag e ajudá -lo a usá -lo em pleno potencial.
| Nome | Hora da reunião | Notas de reunião | Discussões |
|---|---|---|---|
| GO RECURSO MENHO COMUNIDADE COMUNIDADE DO | A cada outra quinta às 10:00 ET / 16:00 CET | Google Doc | VC Link (Meet) |
Muito obrigado aos nossos colaboradores.
Torne -se um patrocinador e mostre seu suporte para ir sinalizador de recursos.
Estes são nossos patrocinadores muito legais!
Se você estiver usando go-feature-flag , incentivamos você a incluir o nome da sua empresa nesta lista. Esse ato simples aumenta significativamente a visibilidade e credibilidade do projeto, fazendo uma contribuição substancial ao seu avanço. Para fazer isso, adicione -se por favor aos adotantes.
Aqui está a lista de adotantes.
