Alibaba Cloud DNS:Android SDK development guide

1. Overview

Alibaba Cloud Public DNS SDK provides DNS resolution services for mobile developers.

With this SDK, developers can easily integrate Alibaba Cloud Public DNS into their Android apps to solve domain name resolution issues and implement precise domain name resolution scheduling at a low cost. You can refer to the demo project source code to learn how to use this SDK.

This SDK encapsulates the DoH JSON API for Alibaba Cloud Public DNS. It provides Java function interfaces for Android apps to resolve domain names and offers efficient domain name caching based on TTL and LRU strategies. In addition to the original features of Public DNS, the SDK also provides the following advantages:

• Ease of use

  Users only need to integrate the SDK to access Alibaba Cloud Public DNS service. The integration method is simple and easy to use, providing a more convenient resolution service.

• Zero latency

  The SDK implements an LRU caching mechanism that caches IP addresses of each domain name resolution to the local device. It also actively updates expired cache to ensure the cache is timely and effective, helping users achieve zero latency for domain name resolution.

2. SDK integration

• You need to register your application in the console first to obtain the unique identifier Account ID

• Then fill in the AccessKey ID and AccessKey Secret authentication parameters in the AndroidManifest.xml file in your project directory

• Integrate the SDK into your app project

2.1 Integrate the SDK through Maven using Gradle

Add the following code to the build.gradle file:

allprojects {
  repositories {
    maven {
      url 'https://maven.aliyun.com/repository/public/'
    }
    mavenLocal()
    mavenCentral()
  }
}

Add the file information you want to reference:

dependencies {
     implementation 'com.alibaba.pdns:alidns-android-sdk:2.2.8'
     implementation 'com.google.code.gson:gson:2.8.5'
}

2.2 Integrate the SDK using the AAR method

Refer to SDK download to obtain the SDK's alidns_android_sdk.aar, and integrate the AAR package into your project's libs directory to use it easily.

2.3 SDK initialization

You need to register your application in the console first to obtain the unique identifier Account ID and authentication parameters AccessKey ID and AccessKey Secret. After integrating the SDK, initialize it. For specific SDK initialization, refer to the code example in the Application:

public class DnsCacheApplication extends Application{

    private String Account ID = "your Account ID"; //Set your Account ID for SDK integration in the console
    private String AccessKey ID = "your AccessKey ID"; //Set your AccessKey ID for SDK integration in the console
    private String AccessKey Secret = "your AccessKey Secret "; //Set your AccessKey Secret for SDK integration in the console

    @Override
    public void onCreate() {
       super.onCreate();
       DNSResolver.Init(this,Account ID,AccessKey ID,AccessKey Secret); //Set the Account ID, AccessKey ID, and AccessKey Secret for SDK integration in the console
       //Note: Setting keep-alive domains will automatically initiate resolution when the TTL reaches 75%, ensuring that domain name resolution always hits the cache. However, if users use CDN, this may result in a very small TTL value, generating many resolution requests and increasing costs. Please use this method with caution.
       DNSResolver.setKeepAliveDomains(new String[]{"Your keep-alive domain 1","Your keep-alive domain 2",...});       
       DNSResolver.getInstance().preLoadDomains(DNSResolver.QTYPE_IPV4,new String[]{"Your preload domain 1","Your preload domain 2",...}); //Set specified IPv4 type domain preresolution, replace preload domains with the domains you want to resolve using Alibaba DNS
    }
}

Additionally, when using the SDK in an Android project, you need to ensure that the following access permissions are configured:

<!--Required permissions-->
   <uses-permission android:name="android.permission.INTERNET"/>
   <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
   <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>

2.4 SDK authentication

Starting from version 2.0, this SDK supports authentication to ensure user identity security and prevent unauthorized third-party use. To enable authentication, please refer to Create a key to create AccessKey ID and AccessKey Secret in the console. If users do not set authentication parameters during SDK initialization, Public DNS will reject domain name resolution requests without authentication enabled in the future, which will cause domain name resolution function to fail and affect users' actual business. Therefore, you must set authentication parameters when initializing the Alibaba Cloud Public DNS SDK.

Authentication parameters can be set in the following way:

DNSResolver.Init(this,Account ID,AccessKey ID,AccessKey Secret);

3. Common issues with SDK integration

1. Android 9.0 reports "cleartext HTTP traffic not permitted" exception when sending HTTP network requests

• Reason: Starting from Android 9.0 (API 28), Android prohibits cleartext network access by default and only allows access to https URLs.

• Solution

Add the following code to <application> in the AndroidManifest.xml file of your application:

android:usesCleartextTraffic="true"

<application
        android:name=".DnsCacheApplication"
        android:icon="@mipmap/ic_launcher"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme"
        android:usesCleartextTraffic="true">

2. Android 9.0 reports exception: Didn't find class BasicHttpParams.

• Reason: Apache Http client is deprecated.

Google removed support for the Apache Http client in Android 6.0. Starting from Android 9.0, org.apache.http.legacy has been removed from the bootclasspath.

This change does not affect most applications with taskVersion < 9.0. For all applications with taskVersion > 9.0, if they continue to use Apache Http interfaces or reference lib packages that use these interfaces, they will encounter exceptions indicating that Apache Http interfaces cannot be found.

• Solution

Add the following to <application> in the AndroidManifest.xml file of your application:

<uses-library android:name="org.apache.http.legacy" android:required="false"/>

3. Starting from version 2.1.9, this SDK introduces JNI, which requires NDK configuration in your app project's development environment

• Add the NDK installation directory in the local.properties file in the root directory of your app project

ndk.dir=...\\ndk\\21.4.7075529   ... is the local path where the developer installed NDK

• Add the following configuration to the gradle.properties file in the root directory of your app project

android.useDeprecatedNdk = true

If your app project already has NDK configured, you can ignore this and do not need to configure it again. For better use of this SDK, we recommend setting the JDK version to 1.8 and the NDK version to 21.4.7075529 when compiling your app.

The SDK supports setting the HTTP request protocol type for DNS resolution, allowing you to choose between HTTP or HTTPS protocols for resolution. The SDK defaults to and recommends using the HTTPS protocol for resolution because the HTTPS protocol is more secure. Public DNS billing is based on the number of HTTP resolution requests, with HTTPS being billed at 5 times the HTTP traffic. Developers can choose the HTTP request protocol type based on their actual business needs.

  /**
   * Preload domain name resolution by automatically detecting the current network environment (IPv4-only, IPv6-only, IPv4 and IPv6 dual-stack)
   * In dual-stack network environments, preload both IPv4 and IPv6 type domain name resolution results. Can be called during SDK initialization when the application starts,
   * to store domain name resolution results in the cache in advance, speeding up subsequent domain name resolution latency.
   *
   * @param domains Domains to preload for resolution
   */
   public void preLoadDomains(final String[] domains)

    /**
     * Specify preloading IPv6 or IPv4 domains for preload resolution
     * Can be called during SDK initialization when the application starts, to store domain name resolution results in the cache in advance, speeding up subsequent domain name resolution latency
     *
     * @param qType Preload resolution for IPv4 or IPv6
     * @param domains Domains to preload for resolution
     */
    public void preLoadDomains(String qType, final String[] domains)
   /**
   * Obtain the resolution data for this domain by automatically detecting the current network environment (IPv4-only, IPv6-only, IPv4 and IPv6 dual-stack)
   * If the resolution result exists in the cache and the cache has not expired, the resolution result in the cache is returned to the user
   * If there is no cache or the cache has expired, it first obtains the recursive resolution result of the domain name from the server through a synchronous network request and returns it to the user, then stores the resolution result in the cache
   *
   * @param host The domain name that the user wants to resolve
   * @return Returns the optimal IP array based on the current network environment
   */
    public String[] getIpsByHost(String host)

/**
    * Obtain the IPv4 record array corresponding to the hostname
    * If the resolution result exists in the cache and the cache has not expired, the resolution result in the cache is returned to the user
    * If there is no cache or the cache has expired, it first obtains the recursive resolution result of the domain name from the server through a synchronous network request and returns it to the user, then stores the resolution result in the cache
    *
    * @param hostName such as (www.taobao.com)
    * @return Returns the array of IPv4 addresses corresponding to the target hostname
    */
  public  String[] getIPsV4ByHost(String hostName) 

   /**
    * Obtain the IPv6 record array corresponding to the hostname
    * @param hostName such as (www.taobao.com)
    * @return Returns the array of IPv6 addresses corresponding to the target hostname
    */
  public String[] getIPsV6ByHost(String hostName) 

  

  /**
   * Obtain the IP array after resolving the domain name from the cache by automatically detecting the current network environment (IPv4-only, IPv6-only, IPv4 and IPv6 dual-stack)
   * If there is no cache, this method first returns null directly, then performs an asynchronous query, and finally stores the queried data in the cache
   * If the resolution result exists in the cache, if returning expired cache resolution results is allowed, it first returns the expired resolution IP to the user, then asynchronously updates the cache resolution result
   * If returning expired cache resolution results is not allowed, when the cache expires, it first returns null to the user directly, then asynchronously updates the cache resolution result
   *
   * @param host The domain name that you query, such as www.taobao.com.
   * @param isAllowExp Specify whether to return the resolution result of the expired domain name.
   * @return Obtain the IP address array from the cache after the host field is resolved.
   */
   public String[] getIpsByHostFromCache(String host, boolean isAllowExp)
   
    /**
     * Obtain the IP address array of the IPv4 record type from the cache after the host field is resolved.
     * If there is no cache, this method first returns null directly, then performs an asynchronous query, and finally stores the queried data in the cache
     * If the resolution result exists in the cache, if returning expired cache resolution results is allowed, it first returns the expired resolution IP to the user, then asynchronously updates the cache resolution result
     * If returning expired cache resolution results is not allowed, when the cache expires, it first returns null to the user directly, then asynchronously updates the cache resolution result
     *
     * @param host The domain name that you query, such as www.taobao.com.
     * @param isAllowExp Specify whether to return the resolution result of the expired domain name.
     * @return Obtain the IP address array of the IPv4 record type from the cache after the host field is resolved.
     */
    private String[] getIpv4ByHostFromCache(String host , boolean isAllowExp)

    /**
     * Obtain the IP address array of the IPv6 record type from the cache after the host field is resolved.
     * If there is no cache, this method first returns null directly, then performs an asynchronous query, and finally stores the queried data in the cache
     * If the resolution result exists in the cache, if returning expired cache resolution results is allowed, it first returns the expired resolution IP to the user, then asynchronously updates the cache resolution result
     * If returning expired cache resolution results is not allowed, when the cache expires, it first returns null to the user directly, then asynchronously updates the cache resolution result
     *
     * @param host The domain name that you query, such as www.taobao.com.
     * @param isAllowExp Specify whether to return the resolution result of the expired domain name.
     * @return Obtain the IP address array of the IPv6 record type from the cache after the host field is resolved.
     */
    private String[] getIpv6ByHostFromCache(String host , boolean isAllowExp)

  /**
  * Obtain the DomainInfo object array in the IPv4 records that correspond to the URL.
  * If the resolution result exists in the cache and the cache has not expired, the resolution result in the cache is returned to the user
  * If there is no cache or the cache has expired, it first obtains the recursive resolution result of the domain name from the server through a synchronous network request and returns it to the user, then stores the resolution result in the cache
  *
  * @param url such as (http://www.taobao.com)
  * @return Obtain the DomainInfo object array in the IPv4 records that correspond to the URL.
  */
  public DomainInfo[] getIPsV4DInfoByUrl(String url) 

  Note: The URL in the DomainInfo object is the URL in which the host field is automatically replaced by a specific IP address. You do not need to manually replace the host field in the URL.

  /**
   * Obtain the DomainInfo object array in the IPv6 records that correspond to the URL.
   * If the resolution result exists in the cache and the cache has not expired, the resolution result in the cache is returned to the user
   * If there is no cache or the cache has expired, it first obtains the recursive resolution result of the domain name from the server through a synchronous network request and returns it to the user, then stores the resolution result in the cache
   * 
   * @param url such as (http://m.taobao.com)
   * @return Obtain the DomainInfo object array in the IPv6 records that correspond to the URL.
   */
   public DomainInfo[] getIPsV6DInfoByUrl(String url) 

  /**
    * Obtain a DomainInfo object in the IPv4 records that correspond to a specific URL.
    * If the resolution result exists in the cache and the cache has not expired, the resolution result in the cache is returned to the user
    * If there is no cache or the cache has expired, it first obtains the recursive resolution result of the domain name from the server through a synchronous network request and returns it to the user, then stores the resolution result in the cache
    *
    * @param url such as (http://m.taobao.com)
    * @return Obtain a DomainInfo object in the IPv4 records that correspond to the URL.
    */
    public DomainInfo getIPV4DInfoByUrl(String url) 


  /**
    * Obtain a DomainInfo object in the IPv6 records that correspond to a specific URL.
    * If the resolution result exists in the cache and the cache has not expired, the resolution result in the cache is returned to the user
    * If there is no cache or the cache has expired, it first obtains the recursive resolution result of the domain name from the server through a synchronous network request and returns it to the user, then stores the resolution result in the cache
    *
    * @param url such as (http://www.taobao.com)
    * @return Obtain a DomainInfo object in the IPv6 records that correspond to the URL.
    */
   public DomainInfo getIPV6DInfoByUrl(String url) 

   Description: The returned domainInfo object mainly encapsulates the following properties

  /**
   * id auto-incrementing ID number for the accessed domain name
    */
    public String id = null;

   /**
    * URL that can be used directly, with the host already replaced by IP
    */
     public String url = null;

    /**
    * The service name that needs to be included in the header of the HTTP request.
    */
    public String host = "";

   /**
    * Returned content body
    */
   public String data = null;

   /**
    * Start request time
    */
   public String startTime = null;

   /**
    * Request end time, this value is null if the request times out
    */
   public String stopTime = null; 

   /**
   * The returned server status code, such as 200, 404, or 500.
   */
   public String code = null;

  /**
    * Obtain the IPv4 record corresponding to the hostname
    * If the resolution result exists in the cache and the cache has not expired, the resolution result in the cache is returned to the user
     * If there is no cache or the cache has expired, it first obtains the recursive resolution result of the domain name from the server through a synchronous network request and returns it to the user, then stores the resolution result in the cache
  
    * @param hostName such as (www.taobao.com)
    * @return A random IPv4 address in the set of IPv4 addresses that correspond to the hostname is returned. If connection speed testing of IP addresses is enabled, the optimal IPv4 address is returned.
    */
  public String getIPV4ByHost(String hostName) 

   /**
    * Obtain the IPv6 record corresponding to the hostname
    * If the resolution result exists in the cache and the cache has not expired, the resolution result in the cache is returned to the user
    * If there is no cache or the cache has expired, it first obtains the recursive resolution result of the domain name from the server through a synchronous network request and returns it to the user, then stores the resolution result in the cache
  
    * @param hostName such as (www.taobao.com)
    * @return Obtain a random IPv6 address in the set of IPv6 addresses that correspond to the hostname. If connection speed testing of IP addresses is enabled, the optimal IPv6 address is returned.
    */
   public String getIPV6ByHost(String hostName) 
      

    /**
     * Obtain the statistics on successful and failed queries of Alibaba Cloud Public DNS.
     *
     * @return Obtain the JSON array string of the resolution statistics on all domain names.
     */
    public String getRequestReportInfo()
    
     /**
     * Set domain cache keep-alive, configured domains will automatically initiate resolution at 75% of TTL, ensuring that configured domains always hit the cache when resolved, improving the resolution efficiency of the SDK.
     * It is recommended not to set too many domains for this feature, the current limit is a maximum of 10 domains, configured separately from pre-resolution
     *
     * @param persistentCacheDomains
     */
    public synchronized static void setKeepAliveDomains(String[] persistentCacheDomains) {
    
     /**
     * Clear the cache of specified domains, clear all domain caches when hostname is null
     *
     * @param domains Array of specified domains to delete from cache
     */
    public void clearHostCache(String[] domains){

URL: The access address passed in, for example: http://www.taobao.com.

 String hostname = "www.taobao.com";
 String url = "http://www.taobao.com";

7.1 Obtain the optimal IP data for the current network environment

String[] ip = DNSResolver.getInstance().getIpsByHost(hostname); //Get the optimal domain name resolution IP for the current network

7.2 Preload domain name resolution based on the current network environment

DNSResolver.getInstance().preLoadDomains(domains) //Set domain pre-resolution, replace preload domains with the domains you want to resolve using Alibaba DNS

7.3 Read domain name resolution data from cache based on the current network environment

String[] ip = DNSResolver.getInstance().getIpsByHostFromCache(hostname,true);//Get domain name resolution data from the cache for the current network environment

7.4 Obtain IPv4 address

String IPV4 = DNSResolver.getInstance().getIPV4ByHost(hostname); //Get IPv4 domain name resolution

7.5 Obtain IPv6 address

String IPV6 =  DNSResolver.getInstance().getIPV6ByHost(hostname) //Get IPv6 domain name resolution

7.6 Get IPv4 resolution address from cache

String[] IPV4 =  DNSResolver.getInstance().getIpv4ByHostFromCache(hostname , true) //Get IPv4 domain name resolution from cache

7.7 Get IPv6 resolution address from cache

String[] IPV6 =  DNSResolver.getInstance().getIpv6ByHostFromCache(hostname , true) //Get IPv6 domain name resolution from cache

7.8 Obtain the DomainInfo object corresponding to a URL

DomainInfo dinfo = DNSResolver.getInstance().getIPV4DInfoByUrl(url); //Get the replaced URL

7.9 Clear the resolution result of a specified domain name from the cache

DNSResolver.getInstance().clearHostCache(hostName); //Clear the cache of a specified domain, set hostName to null to clear all domain caches

7.10 Obtain statistics on successful and failed queries of Alibaba DNS

String reportInfo = DNSResolver.getInstance().getRequestReportInfo();//Get success and failure statistics

The field descriptions in the JSON string array of all domain name resolution statistics are as follows:

 [
      {
         "avgRtt":"1",                         // Average domain resolution time, unit: milliseconds (ms)
         "degradeLocalDnsCount": 0,            // Number of times degraded to LocalDNS                       
         "domainName":"www.example.com",       // Resolved domain name
         "hitDnsCacheCount": 1,                // Number of cache hits
         "httpabnormalCount": 0,               // Number of recursive request failures
         "isp": "China Mobile",                // ISP name
         "localDnsResolveErrCount": 0,         // Number of LocalDNS resolution failures
         "maxRtt": 8.0,                        // Maximum domain resolution time, unit: milliseconds (ms)          
         "nonetworkCount": 0,                  // Number of no network occurrences
         "permissionErrCount": 0,              // Number of user authentication failures
         "queryType": 1,                       // IP type, 1 represents IPv4, 28 represents IPv6
         "recursiveReqCount": 1,               // Number of recursive queries
         "reqParameterErrCount": 0,            // Number of request parameter format errors
         "reqPathErrCount": 0,                 // Number of URL errors
         "reqServerErrCount": 0,               // Number of DNS server errors
         "reqTimeoutCount": 0,                 // Number of DNS service timeout errors
         "resolveSuccessCount": 1,             // Number of successful resolutions
         "timeoutCount": 0,                    // Number of network timeout errors
         "utfNetWorkErroNum": 0                // Number of data reporting timeout errors
      }
         ......
 ]

8. Example

public class MainActivity extends AppCompatActivity {
   private Button button;
   private TextView tvInfo;
   private TextView tvResult;
   private String hostUrl = "http://www.taobao.com"; //Please replace with your hostUrl to be resolved
   private String hostName = "www.taobao.com"; //Please replace with your hostName to be resolved
   private static final String TAG = "PDnsDemo";
   private static ExecutorService pool = Executors.newSingleThreadExecutor();
   private static final String PDNS_RESULT = "pdns_result";
   private static final int SHOW_CONSOLE_TEXT = 10000;
   private Handler mHandler;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.demo_activity_main);
       init();
       initHandler();
   }

 private void init() {
       tvInfo = findViewById(R.id.tv_respons_info);
       tvResult = findViewById(R.id.tv_respons);
       button = findViewById(R.id.btn_onclik);
       button.setOnClickListener(new View.OnClickListener() {
           public void onClick(View view) {
               new Thread(new Runnable() {
                      @Override
                      public void  run() {
                      //Call the getIPV4ByHost method in Alibaba Public SDK to obtain the IP after the target domain name is resolved
                      String ip = DNSResolver.getInstance().getIPV4ByHost(hostName);
                      if(ip != null){
                         tvInfo.setText("The IP of your resolved domain is: "+ ip);
                      }
                      //Call the getIPV4DInfoByUr operation in Alibaba Cloud Public SDK to obtain the URL in the domainInfo object after the specified domain name is resolved. The URL is the one in which the host field is replaced by an IP address.
                      DomainInfo dinfo = DNSResolver.getInstance().getIPV4DInfoByUrl(hostUrl);
                      if (dinfo != null) {
                           showResponse(dinfo);
                      }
                   }
               }).start();
           }
       });
   }

   private void initHandler() {
       mHandler = new Handler() {
           @Override
           public void handleMessage(Message msg) {
               switch (msg.what)  {
                   case SHOW_CONSOLE_TEXT:
                       tvResult.setText(msg.getData().getString(PDNS_RESULT) + "\n");
                       break;
               }
           }
       };
   }

   private void showResponse(final DomainInfo dinfo) {
                //Send network request
               String requestUrl = dinfo.url;
               HttpURLConnection conn = null;
               try {
                   URL url = new URL(requestUrl);
                   conn = (HttpURLConnection) url.openConnection();
                   //When an IP address is used for access, you must set the host field in the HTTP request header to the resolved domain name.
                   conn.setRequestProperty("Host", url.getHost());//Set the HOST field in the HTTP request header
                   DataInputStream dis = new DataInputStream(conn.getInputStream());
                   int len;
                   byte[] buff = new byte[4096];
                   StringBuilder response = new StringBuilder();
                   while ((len = dis.read(buff)) != -1) {
                       response.append(new String(buff, 0, len));
                   }
                   Log.d(TAG, "Response: " + response.toString());
                   dis.close();
                   sendMessage(response.toString());
               } catch (IOException e) {
                   e.printStackTrace();
               }finally {
                   if (conn != null) {
                       conn.disconnect();
                   }
               }
           }

   private void sendMessage(String message) {
       if (mHandler != null) {
               Message msg = mHandler.obtainMessage();
               Bundle bundle = new Bundle();
               bundle.putString(PDNS_RESULT, message);
               msg.setData(bundle);
               msg.what = SHOW_CONSOLE_TEXT;
               mHandler.sendMessage(msg);
       }
   }
}

public class DnsCacheApplication extends Application {
    
    private String Account ID = "your Account ID"; //Set your Account ID for SDK integration in the console
    private String AccessKey ID = "your AccessKey ID"; //Set your AccessKey ID for SDK integration in the console
    private String AccessKey Secret = "your AccessKey Secret"; //Set your AccessKey Secret for SDK integration in the console

    @Override
    public void onCreate() {
       super.onCreate();
       DNSResolver.Init(this,Account ID,AccessKey ID,AccessKey Secret); //Set the Account ID, AccessKey ID, and AccessKey Secret for SDK integration in the console
       DNSResolver.setKeepAliveDomains(new String[]{"User specified domain 1","User specified domain 2",...}); //Setting keep-alive domains will automatically initiate resolution at 75% of TTL, ensuring that domain name resolution always hits the cache
       DNSResolver.getInstance().preLoadDomains(DNSResolver.QTYPE_IPV4,new String[]{"Your preload domain 1","Your preload domain 2",...}); //Set specified IPv4 type domain preresolution, replace preload domains with the domains you want to resolve using Alibaba DNS
    }
}

Notes

1. After you use Alibaba Cloud Public DNS to resolve a domain name to an IP address, you can use the IP address to send business requests. You must specify the host field in the HTTP request header as the domain name that has been resolved.

2. To ensure normal business operations, when the IP corresponding to the domain name resolution obtained through Alibaba Cloud Public DNS SDK is empty, application developers need to use the original domain name request URL for downgraded requests. Example code is as follows:

   String ip = DNSResolver.getInstance().getIPV4ByHost("domain name");
   if (ip != null) {
   	//Replace the host in the URL with IP for interface requests
   }else {
   	//Use the original domain name request URL for downgraded requests (use the original URL with domain name for network requests)
   }

3. To help users use Alibaba Cloud Public DNS SDK more quickly, we provide a demo program for developers to download for reference. Click here to download the demo program.

4. After users complete SDK integration, to verify whether the integration is successful, they need to check if there is traffic generated in the "Traffic Analysis" section of the console. If no traffic is generated, please check whether the Account ID, AccessKey ID and AccessKey Secret parameters are set correctly.