Az alkalmazás migrálása az Amazon DynamoDB-ből az Azure Cosmos DB-be

A KÖVETKEZŐRE VONATKOZIK: NoSQL

Az Azure Cosmos DB egy skálázható, globálisan elosztott, teljes mértékben felügyelt adatbázis. Garantáltan alacsony késésű hozzáférést biztosít az adatokhoz. Az Azure Cosmos DB-ről további információt az áttekintési cikkben talál. Ez a cikk azt ismerteti, hogyan migrálhatja a .NET-alkalmazást a DynamoDB-ből az Azure Cosmos DB-be minimális kódmódosításokkal.

Fogalmi különbségek

Az Alábbiakban az Azure Cosmos DB és a DynamoDB fő fogalmi különbségeit mutatjuk be:

Szerkezeti különbségek

Az Azure Cosmos DB egyszerűbb JSON-struktúrával rendelkezik a DynamoDB-hez képest. Az alábbi példa a különbségeket mutatja be

DynamoDB:

A következő JSON-objektum a DynamoDB adatformátumát jelöli

{
TableName: "Music",
KeySchema: [
{ 
  AttributeName: "Artist",
  KeyType: "HASH", //Partition key
},
{ 
  AttributeName: "SongTitle",
  KeyType: "RANGE" //Sort key
}
],
AttributeDefinitions: [
{ 
  AttributeName: "Artist",
  AttributeType: "S"
},
{ 
  AttributeName: "SongTitle",
  AttributeType: "S"
}
],
ProvisionedThroughput: {
  ReadCapacityUnits: 1,
  WriteCapacityUnits: 1
 }
}

Azure Cosmos DB:

Az alábbi JSON-objektum az Adatformátumot jelöli az Azure Cosmos DB-ben

{
"Artist": "",
"SongTitle": "",
"AlbumTitle": "",
"Year": 9999,
"Price": 0.0,
"Genre": "",
"Tags": ""
}

Kód áttelepítése

Ez a cikk egy alkalmazás kódjának az Azure Cosmos DB-be való migrálására terjed ki, amely az adatbázis-migrálás kritikus eleme. A tanulási görbe csökkentése érdekében az alábbi szakaszok az Amazon DynamoDB és az Azure Cosmos DB egyenértékű kódrészletének egymás melletti összehasonlítása.

A forráskód letöltéséhez klónozza a következő adattárat:

git clone https://github.com/Azure-Samples/DynamoDB-to-CosmosDB

Előfeltételek

• .NET-keretrendszer 4.7.2

• A legújabb Visual Studio az Azure fejlesztési számítási feladatával. Első lépésként használhatja az ingyenes Visual Studio Community IDE-t. Engedélyezze az Azure fejlesztési számítási feladatát a Visual Studio beállítása során.

• Hozzáférés az Azure Cosmos DB for NoSQL-fiókhoz
• Az Amazon DynamoDB helyi telepítése
• Java 8
• Futtassa az Amazon DynamoDB letölthető verzióját a 8000-es porton (módosíthatja és konfigurálhatja a kódot)

A kód beállítása

Adja hozzá a következő "NuGet-csomagot" a projekthez:

Install-Package Microsoft.Azure.Cosmos

Kapcsolat létrehozása

DynamoDB:

Az Amazon DynamoDB-ben a következő kód használható a csatlakozáshoz:

    AmazonDynamoDBConfig addbConfig = new AmazonDynamoDBConfig() ;
        addbConfig.ServiceURL = "endpoint";
        try { aws_dynamodbclient = new AmazonDynamoDBClient( addbConfig ); }

Azure Cosmos DB:

Az Azure Cosmos DB csatlakoztatásához frissítse a kódot a következőre:

client_documentDB = new CosmosClient(
    "<nosql-account-endpoint>",
    tokenCredential
);

A kapcsolat optimalizálása az Azure Cosmos DB-ben

Az Azure Cosmos DB-vel az alábbi lehetőségeket használhatja a kapcsolat optimalizálásához:

• ConnectionMode – Közvetlen kapcsolati mód használata az Azure Cosmos DB szolgáltatás adatcsomópontjaihoz való csatlakozáshoz. Átjáró mód használata csak a logikai címek inicializálására és gyorsítótárazására, valamint a frissítések frissítésére. További információ: kapcsolati módok.

• ApplicationRegion – Ez a beállítás az Azure Cosmos DB-vel való interakcióhoz használt előnyben részesített georeplikált régió beállítására szolgál. További információkért lásd a globális terjesztést.

• Konzisztenciaszint – Ezzel a beállítással felülbírálhatja az alapértelmezett konzisztenciaszintet. További információ: konzisztenciaszintek.

• BulkExecutionMode – Ezzel a beállítással tömeges műveleteket hajthat végre az AllowBulkExecution tulajdonság igaz értékre állításával. További információ: tömeges importálás.

  client_cosmosDB = new CosmosClient(" Your connection string ",new CosmosClientOptions()
  { 
    ConnectionMode=ConnectionMode.Direct,
    ApplicationRegion=Regions.EastUS2,
    ConsistencyLevel=ConsistencyLevel.Session,
    AllowBulkExecution=true  
  });
  

A tároló létrehozása

DynamoDB:

Az adatok Amazon DynamoDB-ben való tárolásához először létre kell hoznia a táblát. A táblalétrehozás folyamatában; a sémát, a kulcstípust és az attribútumokat az alábbi kódban látható módon határozza meg:

// movies_key_schema
public static List<KeySchemaElement> movies_key_schema
  = new List<KeySchemaElement>
{
  new KeySchemaElement
  {
    AttributeName = partition_key_name,
    KeyType = "HASH"
  },
  new KeySchemaElement
  {
    AttributeName = sort_key_name,
    KeyType = "RANGE"
  }
};

// key names for the Movies table
public const string partition_key_name = "year";
public const string sort_key_name      = "title";
  public const int readUnits=1, writeUnits=1; 

    // movie_items_attributes
    public static List<AttributeDefinition> movie_items_attributes
  = new List<AttributeDefinition>
{
  new AttributeDefinition
  {
    AttributeName = partition_key_name,
    AttributeType = "N"
  },
  new AttributeDefinition
  {
    AttributeName = sort_key_name,
    AttributeType = "S"
  }

CreateTableRequest  request;
CreateTableResponse response;

// Build the 'CreateTableRequest' structure for the new table
request = new CreateTableRequest
{
  TableName             = table_name,
  AttributeDefinitions  = table_attributes,
  KeySchema             = table_key_schema,
  // Provisioned-throughput settings are always required,
  // although the local test version of DynamoDB ignores them.
  ProvisionedThroughput = new ProvisionedThroughput( readUnits, writeUnits );
};

Azure Cosmos DB:

Az Amazon DynamoDB-ben ki kell építenie az olvasási számítási egységeket és az írási számítási egységeket. Míg az Azure Cosmos DB-ben kérelemegységként (RU/s) adja meg az átviteli sebességet, amely bármely művelethez dinamikusan használható. Az adatok adatbázisként (tárolóként)>> lesznek rendszerezve. Az átviteli sebességet adatbázisszinten, gyűjteményszinten vagy mindkettőben megadhatja.

Adatbázis létrehozása:

await client_cosmosDB.CreateDatabaseIfNotExistsAsync(movies_table_name);

A tároló létrehozása:

await cosmosDatabase.CreateContainerIfNotExistsAsync(new ContainerProperties() { PartitionKeyPath = "/" + partitionKey, Id = new_collection_name }, provisionedThroughput);

Az adatok betöltése

DynamoDB:

Az alábbi kód bemutatja, hogyan töltheti be az adatokat az Amazon DynamoDB-ben. A moviesArray a JSON-dokumentum listájából áll, majd át kell haladnia, és be kell töltenie a JSON-dokumentumot az Amazon DynamoDB-be:

int n = moviesArray.Count;
for( int i = 0, j = 99; i < n; i++ )
    {
  try
  {
    string itemJson = moviesArray[i].ToString();
    Document doc = Document.FromJson(itemJson);
    Task putItem = moviesTable.PutItemAsync(doc);
    if( i >= j )
    {
      j++;
      Console.Write( "{0,5:#,##0}, ", j );
      if( j % 1000 == 0 )
        Console.Write( "\n " );
      j += 99;
    }
    await putItem;

Azure Cosmos DB:

Az Azure Cosmos DB-ben választhatja a streamelést és az írást.moviesContainer.CreateItemStreamAsync() Ebben a mintában azonban a JSON deszerializálva lesz a MovieModel típusba a típusmegjelenítési funkció bemutatásához. A kód többszálas, amely az Azure Cosmos DB elosztott architektúráját használja, és felgyorsítja a betöltést:

List<Task> concurrentTasks = new List<Task>();
for (int i = 0, j = 99; i < n; i++)
{
  try
  {
      MovieModel doc= JsonConvert.DeserializeObject<MovieModel>(moviesArray[i].ToString());
      doc.Id = Guid.NewGuid().ToString();
      concurrentTasks.Add(moviesContainer.CreateItemAsync(doc,new PartitionKey(doc.Year)));
      {
          j++;
          Console.Write("{0,5:#,##0}, ", j);
          if (j % 1000 == 0)
              Console.Write("\n               ");
          j += 99;
      }
      
  }
  catch (Exception ex)
  {
      Console.WriteLine("\n     ERROR: Could not write the movie record #{0:#,##0}, because:\n       {1}",
                          i, ex.Message);
      operationFailed = true;
      break;
  }
}
await Task.WhenAll(concurrentTasks);

Dokumentum létrehozása

DynamoDB:

Az új dokumentum írása az Amazon DynamoDB-ben nem biztonságos, az alábbi példa a newItem-et használja dokumentumtípusként:

Task<Document> writeNew = moviesTable.PutItemAsync(newItem, token);
await writeNew;

Azure Cosmos DB:

Az Azure Cosmos DB adatmodellen keresztül biztosítja a gépelés biztonságát. A "MovieModel" nevű adatmodellt használjuk:

public class MovieModel
{
    [JsonProperty("id")]
    public string Id { get; set; }
    [JsonProperty("title")]
    public string Title{ get; set; }
    [JsonProperty("year")]
    public int Year { get; set; }
    public MovieModel(string title, int year)
    {
        this.Title = title;
        this.Year = year;
    }
    public MovieModel()
    {

    }
    [JsonProperty("info")]
    public   MovieInfo MovieInfo { get; set; }

    internal string PrintInfo()
    {
        if(this.MovieInfo!=null)
        return            string.Format("\nMovie with title:{1}\n Year: {2}, Actors: {3}\n Directors:{4}\n Rating:{5}\n", this.Id, this.Title, this.Year, String.Join(",",this.MovieInfo.Actors), this.MovieInfo, this.MovieInfo.Rating);
        else
            return string.Format("\nMovie with  title:{0}\n Year: {1}\n",  this.Title, this.Year);
    }
}

Az Azure Cosmos DB newItem-ben a MovieModel lesz:

 MovieModel movieModel = new MovieModel()
            {
                Id = Guid.NewGuid().ToString(),
                Title = "The Big New Movie",
                Year = 2018,
                MovieInfo = new MovieInfo() { Plot = "Nothing happens at all.", Rating = 0 }
            };
    var writeNew= moviesContainer.CreateItemAsync(movieModel, new Microsoft.Azure.Cosmos.PartitionKey(movieModel.Year));
    await writeNew;

Dokumentum olvasása

DynamoDB:

Az Amazon DynamoDB-ben való olvasáshoz primitíveket kell definiálnia:

// Create Primitives for the HASH and RANGE portions of the primary key
Primitive hash = new Primitive(year.ToString(), true);
Primitive range = new Primitive(title, false);

  Task<Document> readMovie = moviesTable.GetItemAsync(hash, range, token);
  movie_record = await readMovie;

Azure Cosmos DB:

Az Azure Cosmos DB esetében azonban a lekérdezés természetes (LINQ):

IQueryable<MovieModel> movieQuery = moviesContainer.GetItemLinqQueryable<MovieModel>(true)
                        .Where(f => f.Year == year && f.Title == title);
// The query is executed synchronously here, but can also be executed asynchronously via the IDocumentQuery<T> interface
    foreach (MovieModel movie in movieQuery)
    {
      movie_record_cosmosdb = movie;
    }

A fenti példában szereplő dokumentumgyűjtemény a következő lesz:

• írja be a biztonságos típust
• adjon meg egy természetes lekérdezési lehetőséget.

Elem módosítása

DynamoDB: Az elem frissítése az Amazon DynamoDB-ben:

updateResponse = await client.UpdateItemAsync( updateRequest );

Azure Cosmos DB:

Az Azure Cosmos DB-ben a frissítés upsert műveletként lesz kezelve, ami azt jelenti, hogy beszúrja a dokumentumot, ha nem létezik:

await moviesContainer.UpsertItemAsync<MovieModel>(updatedMovieModel);

Dokumentum törlése

DynamoDB:

Ha törölni szeretne egy elemet az Amazon DynamoDB-ben, ismét primitívekre kell esnie:

Primitive hash = new Primitive(year.ToString(), true);
      Primitive range = new Primitive(title, false);
      DeleteItemOperationConfig deleteConfig = new DeleteItemOperationConfig( );
      deleteConfig.ConditionalExpression = condition;
      deleteConfig.ReturnValues = ReturnValues.AllOldAttributes;
      
  Task<Document> delItem = table.DeleteItemAsync( hash, range, deleteConfig );
        deletedItem = await delItem;

Azure Cosmos DB:

Az Azure Cosmos DB-ben lekérhetjük a dokumentumot, és aszinkron módon törölhetjük őket:

var result= ReadingMovieItem_async_List_CosmosDB("select * from c where c.info.rating>7 AND c.year=2018 AND c.title='The Big New Movie'");
while (result.HasMoreResults)
{
  var resultModel = await result.ReadNextAsync();
  foreach (var movie in resultModel.ToList<MovieModel>())
  {
    await moviesContainer.DeleteItemAsync<MovieModel>(movie.Id, new PartitionKey(movie.Year));
  }
  }

Dokumentumok lekérdezése

DynamoDB:

Az Amazon DynamoDB-ben api-függvények szükségesek az adatok lekérdezéséhez:

QueryOperationConfig config = new QueryOperationConfig( );
  config.Filter = new QueryFilter( );
  config.Filter.AddCondition( "year", QueryOperator.Equal, new DynamoDBEntry[ ] { 1992 } );
  config.Filter.AddCondition( "title", QueryOperator.Between, new DynamoDBEntry[ ] { "B", "Hzz" } );
  config.AttributesToGet = new List<string> { "year", "title", "info" };
  config.Select = SelectValues.SpecificAttributes;
  search = moviesTable.Query( config ); 

Azure Cosmos DB:

Az Azure Cosmos DB-ben egy egyszerű SQL-lekérdezésen belül végezhet vetítést és szűrést:

var result = moviesContainer.GetItemQueryIterator<MovieModel>( 
  "select c.Year, c.Title, c.info from c where Year=1998 AND (CONTAINS(Title,'B') OR CONTAINS(Title,'Hzz'))");

Tartományműveletek esetén, például a "kettő között" az Amazon DynamoDB-ben kell elvégeznie a vizsgálatot:

ScanRequest sRequest = new ScanRequest
{
  TableName = "Movies",
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#yr", "year" }
  },
  ExpressionAttributeValues = new Dictionary<string, AttributeValue>
  {
      { ":y_a", new AttributeValue { N = "1960" } },
      { ":y_z", new AttributeValue { N = "1969" } },
  },
  FilterExpression = "#yr between :y_a and :y_z",
  ProjectionExpression = "#yr, title, info.actors[0], info.directors, info.running_time_secs"
};

ClientScanning_async( sRequest ).Wait( );

Az Azure Cosmos DB-ben sql-lekérdezést és egysoros utasítást használhat:

var result = moviesContainer.GetItemQueryIterator<MovieModel>( 
  "select c.title, c.info.actors[0], c.info.directors,c.info.running_time_secs from c where BETWEEN year 1960 AND 1969");

Tároló törlése

DynamoDB:

Ha törölni szeretné a táblát az Amazon DynamoDB-ben, megadhatja a következőket:

client.DeleteTableAsync( tableName );

Azure Cosmos DB:

Ha törölni szeretné a gyűjteményt az Azure Cosmos DB-ben, megadhatja a következőket:

await moviesContainer.DeleteContainerAsync();

Ezután törölje az adatbázist is, ha szükséges:

await cosmosDatabase.DeleteAsync();

Mint látható, az Azure Cosmos DB támogatja a természetes lekérdezéseket (SQL), a műveletek aszinkronok és sokkal egyszerűbbek. Az összetett kódot egyszerűen migrálhatja az Azure Cosmos DB-be, ami a migrálás után egyszerűbbé válik.

Következő lépések

• További információ a teljesítményoptimalizálásról.
• További információ az olvasások és írások optimalizálásáról
• Tudnivalók az Azure Cosmos DB monitorozásáról