App Configuration SDK del client React
Per migliorare la sicurezza delle applicazioni che utilizzano il 'ibm-appconfiguration-react-client-sdk, si raccomanda vivamente di utilizzare una APIKey criptata al posto della APIKey semplice nel metodo init. Questa
modifica è fondamentale per evitare l'esposizione di credenziali sensibili quando gli utenti ispezionano l'applicazione web. Se si utilizza già una APIKey semplice, aggiornare l'applicazione per generare e utilizzare la APIKey crittografata
secondo i passaggi indicati qui.
Panoramica
IBM Cloud App Configuration React Client SDK è utilizzato per eseguire la valutazione dei flag delle funzionalità e delle proprietà nelle applicazioni web e per tracciare metriche personalizzate per la sperimentazione in base alla configurazione del servizio IBM Cloud App Configuration.
IBM Cloud App Configuration è un servizio centralizzato per la gestione e la configurazione di funzionalità su IBM Cloud per l'uso con applicazioni web e mobili, microservizi e ambienti distribuiti ambienti distribuiti.
Strumentate le vostre applicazioni web con il App Configuration React Client SDK e utilizzare la dashboard, la CLI o l'API di App Configuration per definire i flag o le proprietà delle funzionalità, organizzate in raccolte e mirate ai segmenti. Attivate gli stati dei flag delle funzioni nel cloud per attivare o disattivare le funzioni nell'applicazione o nell'ambiente, quando necessario. Eseguite esperimenti e misurate l'effetto dei flag delle funzionalità sugli utenti finali tracciando metriche personalizzate. È anche possibile gestire le proprietà delle applicazioni distribuite in modo centralizzato.
Compatibilità: l'SDK è compatibile con React versione 16.8.0 e successive. Questo SDK si basa su App Configuration JavaScript Client SDK per fornire una migliore integrazione per l'uso nelle applicazioni React. Di conseguenza, gran parte delle funzionalità del App Configuration JavaScript Client SDK è disponibile anche per l'SDK React Client. Per saperne di più su App Configuration JavaScript Client SDK da qui.
Integrazione dell'SDK client per React
Installazione
Installa l'SDK.
npm install ibm-appconfiguration-react-client-sdk
Inizializza l'SDK
Inizializza l'SDK per connetterti all'istanza del servizio App Configuration, come mostrato nell'esempio seguente. L'impacchettamento del componente dell'applicazione con AppConfigProvider consente di accedere alle funzioni e
alle proprietà da qualsiasi livello della gerarchia del componente.
import { withAppConfigProvider } from 'ibm-appconfiguration-react-client-sdk';
(async () => {
const AppConfigProvider = await withAppConfigProvider({
region: 'us-south',
guid: '<guid>',
apikey: '<encrypted_apikey>',
collectionId: 'airlines-webapp',
environmentId: 'dev'
})
ReactDOM.render(
<AppConfigProvider>
<YourApp />
</AppConfigProvider>,
document.getElementById('root')
);
})();
- regione : Nome della regione in cui viene creata l'istanza del servizio App Configuration. Vedere l'elenco delle località supportate qui. Ad esempio:
us-south,au-sydecc. - guid : Id dell'istanza del servizio App Configuration. Si ottiene dalla sezione credenziali di servizio della dashboard App Configuration.
- apikey : la APIKey crittografata generata come descritto qui.
- collectionId: Id della raccolta creata nell'istanza del servizio App Configuration nella sezione Collezioni.
- environmentId: Id dell'ambiente creato nell'istanza del servizio App Configuration nella sezione Ambienti.
Utilizzare sempre l'APIKey crittografata per evitare di esporre informazioni sensibili.
Assicurarsi di creare le credenziali del servizio con il ruolo 'Client SDK, che ha le autorizzazioni di accesso minime
adatte all'uso in applicazioni basate su browser.
Esempi per l'uso di API correlate a funzioni e proprietà
Vedi i seguenti esempi per l'utilizzo delle API correlate alla funzione.
Ottieni funzione singola
import { useFeature } from 'ibm-appconfiguration-react-client-sdk';
const feature = useFeature('featureId'); // returns undefined incase the featureId is invalid or doesn't exist
if (feature !== undefined) {
console.log(`Feature Name ${feature.getFeatureName()} `);
console.log(`Feature Id ${feature.getFeatureId()} `);
console.log(`Feature Type ${feature.getFeatureDataType()} `);
console.log(`Is feature enabled? ${feature.isEnabled()} `);
}
Ottieni tutte le funzioni
import { useFeatures } from 'ibm-appconfiguration-react-client-sdk';
const features = useFeatures();
const feature = features['featureId'];
if (feature !== undefined) {
console.log(`Feature Name ${feature.getFeatureName()} `);
console.log(`Feature Id ${feature.getFeatureId()} `);
console.log(`Feature Type ${feature.getFeatureDataType()} `);
console.log(`Is feature enabled? ${feature.isEnabled()} `);
}
Valuta una funzione
È possibile utilizzare il metodo feature.getCurrentValue(entityId, entityAttributes) per valutare il valore dell'indicatore di funzione. Questo metodo restituisce uno dei valori Abilitato / Disabilitato / Sovrascritto basato
sulla valutazione. Il tipo di dati del valore restituito corrisponde a quello dell'indicatore funzione. Inoltrare un entityId univoco come parametro per eseguire la valutazione dell'indicatore della funzione.
const entityId = 'john_doe';
const entityAttributes = {
city: 'Bangalore',
country: 'India',
};
const feature = useFeature('featureId');
const featureValue = feature.getCurrentValue(entityId, entityAttributes);
Dove:
entityId: ID dell'entità. Questo sarà un identificativo stringa relativo all'entità rispetto alla quale viene valutata la funzione. Ad esempio, un'entità può essere un'istanza di un'applicazione eseguita su un dispositivo mobile o un utente che accede all'applicazione web. Per interagire con App Configuration, qualsiasi entità deve fornire un ID entità univoco.entityAttributes: un oggetto JSON costituito dal nome attributo e dai relativi valori che definiscono l'entità specificata. Questo è un parametro facoltativo se l'indicatore della funzione non è configurato con alcuna definizione di destinazione. Se la destinazione è configurata, entityAttributes deve essere fornito per la valutazione della regola. Un attributo è un parametro utilizzato per definire un segmento. L'SDK utilizza i valori degli attributi per determinare se l'entità specificata soddisfa le regole di destinazione e restituisce il valore dell'indicatore della funzione appropriato.
Inviare metriche personalizzate
Registrare metriche personalizzate usando l'hook 'useTrack nella sperimentazione.
import { useTrack } from 'ibm-appconfiguration-react-client-sdk';
export default MyComponent = function () {
const trackEvent = useTrack();
return (
<button onClick={() => trackEvent('clicked', 'user123')}>Buy</button>
)
}
Ottieni singola propriet ...
import { useProperty } from 'ibm-appconfiguration-react-client-sdk';
const property = useProperty('propertyId'); // returns undefined incase the propertyId is invalid or doesn't exist
if (property !== undefined) {
console.log(`Property Name ${property.getPropertyName()} `);
console.log(`Property Id ${property.getPropertyId()} `);
console.log(`Property Type ${property.getPropertyDataType()} `);
}
Ottieni tutte le proprietà
import { useProperties } from 'ibm-appconfiguration-react-client-sdk';
const properties = useProperties();
const property = properties['propertyId'];
if (property !== undefined) {
console.log(`Property Name ${property.getPropertyName()} `);
console.log(`Property Id ${property.getPropertyId()} `);
console.log(`Property Type ${property.getPropertyDataType()} `);
}
Valuta una proprietà
Utilizzare il metodo property.getCurrentValue(entityId, entityAttributes) per valutare il valore della proprietà. Questo metodo restituisce il valore della proprietà predefinito o il relativo valore sovrascritto in base alla
valutazione. Il tipo di dati del valore restituito corrisponde a quello della proprietà.
const entityId = 'john_doe';
const entityAttributes = {
city: 'Bangalore',
country: 'India',
};
const property = useProperty('propertyId');
const propertyValue = property.getCurrentValue(entityId, entityAttributes);
Dove:
entityId: ID dell'entità. Questo sarà un identificativo stringa relativo all'entità rispetto alla quale viene valutata la proprietà. Per interagire con App Configuration, qualsiasi entità deve fornire un ID entità univoco.entityAttributes: un oggetto JSON costituito dal nome attributo e dai relativi valori che definiscono l'entità specificata. Questo è un parametro facoltativo se la proprietà non è configurata con alcuna definizione di destinazione. Se la destinazione è configurata, entityAttributes deve essere fornito per la valutazione della regola. Un attributo è un parametro utilizzato per definire un segmento. L'SDK utilizza i valori degli attributi per stabilire se l'entità specificata soddisfa le regole di destinazione e restituisce il valore della proprietà appropriato.
Utilizzo dei valori di fallback con l'SDK React Client
In caso di errore di connessione con il App Configuration, l'SDK si basa sui valori dei flag valutati più di recente e conservati in memoria. Tuttavia, se non esistono valori precedenti in memoria, è consigliabile che gli utenti stabiliscano valori di ripiego all'interno del loro codice, per garantire un funzionamento regolare. Un esempio che mostra questo approccio di ripiego è fornito dal seguente esempio.
import { useFeatures } from 'ibm-appconfiguration-react-client-sdk';
export default function App {
const features = useFeatures();
const defaultFlagValues = {
'flight-booking': false
}
const entityId = 'john_doe';
const entityAttributes = {
city: 'Bangalore',
country: 'India',
};
const getAppConfigurationFlags = (featureID, features) => {
if (Object.keys(features).length === 0 && features.constructor === Object) {
return defaultFlagValues[featureID];
}
return feature[featureID]
? feature[featureID].getCurrentValue(entityId, entityAttributes)
: defaultFlagValues[featureID];
};
return getAppConfigurationFlags('flight-booking', features) ? <div>Flight Booking</div> : '';
}
Tipi di dati supportati
il servizio App Configuration permette di configurare il flag della funzione e le proprietà nei seguenti tipi di dati : Booleano, Numerico, stringa. Il tipo di dati String può avere il formato di una stringa di testo, JSON o YAML. L'SDK elabora ogni formato di conseguenza, come mostrato nella tabella seguente.
Visualizza tabella
| Valore della caratteristica o della proprietà | DataType | DataFormat | Tipo di dati restituiti ' da ' getCurrentValue() |
Output di esempio |
|---|---|---|---|---|
true |
BOOLEAN | non applicabile | boolean |
true |
25 |
NUMERIC | non applicabile | number |
25 |
| "una stringa di testo" | STRINGA | TESTO | string |
a string text |
{ |
STRINGA | JSON | JSON object |
{"firefox":{"name":"Firefox","pref_url":"about:config"}} |
uomini: |
STRINGA | YAML | string |
`"men:
|
Utilizzo del flag di funzionalità Esempio
const feature = useFeature('json-feature');
feature.getFeatureDataType(); // STRING
feature.getFeatureDataFormat(); // JSON
// Example (traversing the returned JSON)
let result = feature.getCurrentValue(entityId, entityAttributes);
console.log(result.key) // prints the value of the key
const feature = useFeature('yaml-feature');
feature.getFeatureDataType(); // STRING
feature.getFeatureDataFormat(); // YAML
feature.getCurrentValue(entityId, entityAttributes); // returns the stringified yaml (check above table)
Esempio di utilizzo della proprietà
const property = useProperty('json-property');
property.getPropertyDataType(); // STRING
property.getPropertyDataFormat(); // JSON
// Example (traversing the returned JSON)
let result = property.getCurrentValue(entityId, entityAttributes);
console.log(result.key) // prints the value of the key
const property = useProperty('yaml-property');
property.getPropertyDataType(); // STRING
property.getPropertyDataFormat(); // YAML
property.getCurrentValue(entityId, entityAttributes); // returns the stringified yaml (check above table)
Licenza
Questo progetto è rilasciato sotto licenza Apache 2.0. Il testo completo della licenza si trova in LICENZA
Ascolta le modifiche della funzione o della proprietà
L'SDK sottoscrive automaticamente il meccanismo basato sugli eventi e riesegue il rendering dei componenti racchiusi quando l'indicatore della funzione o la configurazione della proprietà cambiano.