Salesforce

Med Adobe Experience Platform kan data hämtas från externa källor samtidigt som du kan strukturera, etikettera och förbättra inkommande data med hjälp av Experience Platform tjänster. Du kan importera data från en mängd olika källor, till exempel Adobe-program, molnbaserad lagring, databaser och många andra.

Experience Platform har stöd för inmatning av data från ett CRM-system från tredje part. Stöd för CRM-providers omfattar Salesforce.

Konfigurera din Salesforce-källa för Experience Platform på Azure azure

Följ stegen nedan för att lära dig hur du kan konfigurera ditt Salesforce-konto för Experience Platform på Azure.

IP-adressen tillåtelselista för anslutning till Azure

Du måste lägga till regionspecifika IP-adresser i tillåtelselista innan du kan ansluta dina källor till Experience Platform på Azure. Om du inte lägger till dina regionspecifika IP-adresser i tillåtelselista kan det leda till fel eller sämre prestanda när du använder källor. Läs sidan IP-adress tillåtelselista om du vill ha mer information.

Fältmappning från Salesforce till XDM

Om du vill upprätta en källanslutning mellan Salesforce och Experience Platform måste Salesforce källdatafälten mappas till rätt mål-XDM-fält innan de hämtas till Experience Platform.

Mer information om fältmappningsregler mellan Salesforce-datamängder och Experience Platform finns i följande:

Konfigurera det automatiska genereringsverktyget för namnutrymmet Salesforce och schemat

Om du vill använda källan Salesforce som en del av B2B-CDP måste du först konfigurera ett Postman-verktyg för att automatiskt generera Salesforce namnutrymmen och scheman. Följande dokumentation innehåller ytterligare information om hur du konfigurerar verktyget Postman:

Med en Experience Platform-utvecklarkonsol och Postman konfigurerad kan du nu börja använda lämpliga miljövärden i din Postman -miljö.

Kör skripten

När din Postman-samling och miljö är konfigurerad kan du nu köra skriptet via gränssnittet Postman.

I gränssnittet Postman väljer du rotmappen för verktyget för autogenerering och sedan Run i den övre rubriken.

Gränssnittet Runner visas. Se till att alla kryssrutor är markerade och välj sedan Run Namespaces and Schemas Autogeneration Utility.

En lyckad begäran skapar B2B-namnutrymmen och scheman enligt betaspecifikationerna.

Konfigurera din Salesforce-källa för Experience Platform på Amazon Web Services aws

Följ stegen nedan för att lära dig hur du kan konfigurera ditt Salesforce-konto för Experience Platform på Amazon Web Services (AWS).

Förhandskrav

Om du vill ansluta ditt Salesforce-konto till Experience Platform i en AWS-region måste du ha följande:

IP-adressen tillåtelselista för anslutning till AWS

Du måste lägga till regionspecifika IP-adresser i tillåtelselista innan du kan ansluta dina källor till Experience Platform på AWS. Mer information finns i guiden om att tillåtslista IP-adresser för att ansluta till Experience Platform på AWS.

Skapa en Salesforce Connected App

Använd först följande för att skapa PEM-filer med certifikat/nyckelpar.

openssl req -newkey rsa:4096 -new -nodes -x509 -days 3650 -keyout key.pem -out cert.pem

Lägg till nödvändiga behörigheter

Lägg till följande behörigheter:

När du har lagt till dina behörigheter måste du aktivera rutan för Issue JSON Web Token (JWT)-based access tokens for named user.

Välj sedan Save, Continue och sedan Manage Customer Details. Använd panelen med konsumentinformation för att hämta följande:

Auktorisera din Salesforce-användare till den anslutna appen

Följ stegen nedan för att få behörighet att använda den anslutna appen:

Generera JWT Bearer-token

Följ stegen nedan för att generera din JWT Bearer-token.

Konvertera nyckelpar till pkcs12

Om du vill generera en JWT Bärartoken måste du först använda följande kommando för att konvertera ditt certifikat/nyckelpar till pkcs12-format. Under det här steget måste du även ange ett exportlösenord när du uppmanas till det.

openssl pkcs12 -export -in cert.pem -inkey key.pem -name jwtcert >jwtcert.p12

Skapa java-nyckelbehållare baserat på pkcs12

Använd sedan följande kommando för att skapa en java-nyckelbehållare baserad på de pkcs12 som du just genererade. Under det här steget måste du även ange ett lösenord för målnyckelbehållare när du uppmanas till det. Dessutom måste du ange det tidigare exportlösenordet som källnyckelbehållarlösenord.

keytool -importkeystore -srckeystore jwtcert.p12 -destkeystore keystore.jks -srcstoretype pkcs12 -alias jwtcert

Bekräfta att ditt keystroke.jks innehåller ett jwtcert-alias

Använd sedan följande kommando för att bekräfta att keystroke.jks innehåller ett jwtcert-alias. Under det här steget uppmanas du att ange lösenordet för målnyckelbehållaren som skapades i det föregående steget.

keytool -keystore keystore.jks -list

Generera signerad token

Använd slutligen Java-klassens JWTExample nedan för att generera din signerade token.

package org.example;

import org.apache.commons.codec.binary.Base64;

import java.io.*;
import java.security.*;
import java.text.MessageFormat;

public class Main {

    public static void main(String[] args) {

        String header = "{\"alg\":\"RS256\"}";
        String claimTemplate = "'{'\"iss\": \"{0}\", \"sub\": \"{1}\", \"aud\": \"{2}\", \"exp\": \"{3}\"'}'";

        try {
            StringBuffer token = new StringBuffer();

            //Encode the JWT Header and add it to our string to sign
            token.append(Base64.encodeBase64URLSafeString(header.getBytes("UTF-8")));

            //Separate with a period
            token.append(".");

            //Create the JWT Claims Object
            String[] claimArray = new String[5];
            claimArray[0] = "{CLIENT_ID}";
            claimArray[1] = "{AUTHORIZED_SALESFORCE_USERNAME}";
            claimArray[2] = "{SALESFORCE_LOGIN_URL}";
            claimArray[3] = Long.toString((System.currentTimeMillis() / 1000) + 2629746*4);
            MessageFormat claims;
            claims = new MessageFormat(claimTemplate);
            String payload = claims.format(claimArray);

            //Add the encoded claims object
            token.append(Base64.encodeBase64URLSafeString(payload.getBytes("UTF-8")));

            //Load the private key from a keystore
            KeyStore keystore = KeyStore.getInstance("JKS");
            keystore.load(new FileInputStream("path/to/keystore"), "keystorepassword".toCharArray());
            PrivateKey privateKey = (PrivateKey) keystore.getKey("jwtcert", "privatekeypassword".toCharArray());

            //Sign the JWT Header + "." + JWT Claims Object
            Signature signature = Signature.getInstance("SHA256withRSA");
            signature.initSign(privateKey);
            signature.update(token.toString().getBytes("UTF-8"));
            String signedPayload = Base64.encodeBase64URLSafeString(signature.sign());

            //Separate with a period
            token.append(".");

            //Add the encoded signature
            token.append(signedPayload);

            System.out.println(token.toString());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Nästa steg

När du har slutfört kravkonfigurationen för ditt Salesforce-konto kan du fortsätta att ansluta ditt Salesforce-konto till Experience Platform och importera dina CRM-data. Läs dokumentationen nedan för mer information:

Anslut Salesforce till Experience Platform med API:er

Dokumentationen nedan innehåller information om hur du ansluter Salesforce till Experience Platform med API:er eller användargränssnittet:

Anslut Salesforce till Experience Platform med användargränssnittet