Manejo de las pilas de mensajes

Clase 26 de 84 • Curso de Azure PaaS 2018

Alejandro Delgado Ceniceros

student•

otra forma de hacer el archivo txt

using (TextWriter tempFile = File.CreateText(path))
                {
                    var msg = queue.GetMessage().AsString;

                    tempFile.WriteLine(msg);
                    Console.WriteLine("CreatedFile");
                }

Luis Abdel Rangel Castro

student•

using Microsoft.Azure;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Queue;
using Microsoft.WindowsAzure.Storage.Blob;
using System;
using System.IO;
using System.Threading.Tasks;
using System.Diagnostics;
using System.Security.Cryptography;
using System.Collections.Generic;
using System.Text;

namespace QueueHandlerNF
{
    class Program
    {
        static async Task Main(string[] args)
        {
            string colaNombre = "mifiladeprocesos";
            string contenedorNombre = "contenedorarchivos";
            int registrosprocesar = 20;

            CloudStorageAccount miCuenta = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("QueueConnectionString"));

            CloudQueueClient clienteColas = miCuenta.CreateCloudQueueClient();
            CloudQueue queue = clienteColas.GetQueueReference(colaNombre);
            bool existeCola = await queue.ExistsAsync();

            if (existeCola)
            {
                CloudBlobClient clienteBlob = miCuenta.CreateCloudBlobClient();
                CloudBlobContainer contenedor = clienteBlob.GetContainerReference(contenedorNombre);
                bool existeContenedor = await contenedor.CreateIfNotExistsAsync();
                existeContenedor = await contenedor.ExistsAsync();

                if (existeContenedor)
                {
                    Console.WriteLine($"Procesando la cola: {colaNombre}");
                    foreach (CloudQueueMessage item in await queue.GetMessagesAsync(registrosprocesar))
                    {
                        Create_Directory("files");
                        string rutaArchivo = Path.Combine(Path.Combine(Directory.GetCurrentDirectory(), "files"), $"Log{item.Id}.txt");
                        using (TextWriter archivoTemp = File.CreateText(rutaArchivo))
                        {
                            string mensaje = item.AsString;
                            archivoTemp.WriteLine(mensaje);
                        }
                        Console.WriteLine($"Archivo creado: {rutaArchivo}");
                        Upload_File(contenedorNombre, rutaArchivo);
                        await queue.DeleteMessageAsync(item);
                    }
                    Console.WriteLine($"Se finalizo de procesar la cola: {colaNombre}");
                }
            }
            else
            {
                Console.WriteLine($"No existe la cola: {colaNombre}");
            }
            Console.ReadLine();
        }

        private static string Create_Directory(string name)
        {
            // Specify the directory you want to manipulate.
            string path = Path.Combine(Directory.GetCurrentDirectory(), name);

            try
            {
                // Determine whether the directory exists.
                if (Directory.Exists(path))
                {
                    Console.WriteLine("That path exists already.");
                    return null;
                }

                // Try to create the directory.
                DirectoryInfo di = Directory.CreateDirectory(path);
                Console.WriteLine("The directory was created successfully at {0}.", Directory.GetCreationTime(path));

                return path;
            }
            catch (Exception ex)
            {
                Console.WriteLine("The process failed: {0}", ex.ToString());
                return null;
            }
            finally
            {
            }
        }

        private static void Upload_File(string containerName, string file)
        {
            if (File.Exists(file))
            {
                System.Diagnostics.Stopwatch sw;

                sw = Stopwatch.StartNew();

                long length = new System.IO.FileInfo(file).Length;

                if (length > 1024000)
                {
                    Upload_File_Block(containerName, file);
                }
                else
                {
                    Upload_File_Stream(containerName, file);
                }

                sw.Stop();

                Console.WriteLine("Runtime in upload process: {0} seconds", sw.Elapsed.TotalMilliseconds / 1000);

            }
            else
            {
                Console.WriteLine("The file does not exists: {0}", Path.GetFileName(file));
                Console.WriteLine("Path: {0}", file);
            }
        }

        private static void Upload_File_Stream(string containerName, string origin_file, string folder = "")
        {
            try
            {
                Console.WriteLine(File.Exists(origin_file) ? "File exists." : "File does not exist.");

                if (File.Exists(origin_file))
                {
                    Console.WriteLine(origin_file);

                    CloudStorageAccount cuentaAlmacenamiento = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
                    CloudBlobClient clienteBlob = cuentaAlmacenamiento.CreateCloudBlobClient();
                    CloudBlobContainer contenedor = clienteBlob.GetContainerReference(containerName);
                    contenedor.CreateIfNotExists();
                    contenedor.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });

                    CloudBlockBlob miBlob = contenedor.GetBlockBlobReference((folder.Length == 0 ? "" : folder + "/") + Path.GetFileName(origin_file));
                    Console.WriteLine("Uploading file...");

                    using (var fileStream = System.IO.File.OpenRead(origin_file))
                    {
                        miBlob.UploadFromStream(fileStream);
                    }

                    Console.WriteLine("The file was uploaded successfully.");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("The process failed: {0}", ex.ToString());
            }
            finally
            {
            }
        }

        public static string GetMD5HashFromStream(byte[] bytes)
        {
            using (MD5 md5 = MD5.Create())
            {
                byte[] hash = md5.ComputeHash(bytes);
                return Convert.ToBase64String(hash);
            }
        }

        private static void Upload_File_Block(string containerName, string origin_file, string folder = "")
        {
            CloudStorageAccount cuentaAlmacenamiento = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
            CloudBlobClient clienteBlob = cuentaAlmacenamiento.CreateCloudBlobClient();
            CloudBlobContainer contenedor = clienteBlob.GetContainerReference(containerName);
            contenedor.CreateIfNotExists();
            contenedor.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });

            CloudBlockBlob blob = contenedor.GetBlockBlobReference((folder.Length == 0 ? "" : folder + "/") + Path.GetFileName(origin_file));
            Console.WriteLine("Uploading file...");

            int blockSize = 256 * 1024; //256 kb

            using (FileStream fileStream = new FileStream(origin_file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            {
                long fileSize = fileStream.Length;

                //block count is the number of blocks + 1 for the last one
                int blockCount = (int)((float)fileSize / (float)blockSize) + 1;

                //List of block ids; the blocks will be committed in the order of this list 
                List<string> blockIDs = new List<string>();

                //starting block number - 1
                int blockNumber = 0;

                try
                {
                    int bytesRead = 0; //number of bytes read so far
                    long bytesLeft = fileSize; //number of bytes left to read and upload

                    //do until all of the bytes are uploaded
                    while (bytesLeft > 0)
                    {
                        Console.WriteLine("blockNumber: {0}/{1}", blockNumber, blockCount);

                        blockNumber++;
                        int bytesToRead;
                        if (bytesLeft >= blockSize)
                        {
                            //more than one block left, so put up another whole block
                            bytesToRead = blockSize;
                        }
                        else
                        {
                            //less than one block left, read the rest of it
                            bytesToRead = (int)bytesLeft;
                        }

                        //create a blockID from the block number, add it to the block ID list
                        //the block ID is a base64 string
                        string blockId =
                          Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(string.Format("BlockId{0}",
                            blockNumber.ToString("0000000"))));
                        blockIDs.Add(blockId);
                        //set up new buffer with the right size, and read that many bytes into it 
                        byte[] bytes = new byte[bytesToRead];
                        fileStream.Read(bytes, 0, bytesToRead);

                        //calculate the MD5 hash of the byte array
                        string blockHash = GetMD5HashFromStream(bytes);

                        //upload the block, provide the hash so Azure can verify it
                        blob.PutBlock(blockId, new MemoryStream(bytes), blockHash);

                        //increment/decrement counters
                        bytesRead += bytesToRead;
                        bytesLeft -= bytesToRead;
                    }

                    //commit the blocks
                    blob.PutBlockList(blockIDs);

                    Console.WriteLine("The file was uploaded successfully.");
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.Print("Exception thrown = {0}", ex);
                }
            }
        }
    }


}

Manejo de las pilas de mensajes

Introducción al Curso de Azure PaaS

Bienvenida al curso de Azure PaaS

Diferencia entre IaaS y PaaS

Escenarios donde IaaS o PaaS Funcionan Adecuadamente

Diferencias de costo entre IaaS y PaaS

Características de PaaS que aprenderás en este curso

Servicios de Almacenamiento de Azure (Storage Services)

Servicios de almacenamiento de Azure

Almacenamiento tipo Blob

Azure Storage Explorer

SDK de .NET para almacenamiento Blob

SDK de .NET para almacenamiento Blob 2.0

Almacenamiento tipo File

Crear y administrar un archivo compartido

Configurando una aplicación para File Storage con .NET

Utilizando el SDK de .NET para File Storage

Almacenamiento tipo Table

SDK de .NET para almacenamiento Table

Manejando tablas por medio del SDK de .Net

Agregar entidades a una tabla

Consultar las entidades de una tabla

Actualizar entidades

Eliminar tablas o entidades

Almacenamiento tipo Colas

SDK de .NET para almacenamiento de Colas

Crear una cola e insertar un mensaje

Seleccionar y eliminar mensajes

Manejo de las pilas de mensajes

API REST de los servicios de Almacenamiento

Casos de uso para cada escenario

Servicios de bases de datos en Azure

Azure SQL

Crear una base de datos desde el portal de Azure

Configuración del firewall de Azure SQL

Crear una base de datos desde línea de comandos

Conectándome a mi base de datos desde VS Code

Operaciones CRUD desde VS Code

Operaciones CRUD desde SQL Management Studio

¿Qué es SQL Data Warehouse?

Usando un api para acceder a blob storage

¿Qué es un almacén de datos?

Creando un almacén de datos de SQL

Conectándome a mi almacén de datos

Extrayendo información de mi fuente de datos (importando información a mi fuente de datos)

Mejores prácticas de uso de un almacén de datos (Despliegue de datos con Power BI)

¿Qué es una base de datos para PostgreSQL?

¿Qué es Azure Cosmos DB?

¿Cómo decidir que base de datos utilizar en cada caso?

Creando una base de datos de PostgreSQL desde el portal

Creando una base de datos de PostgreSQL desde terminal

Conectándome desde .NET a mi base de datos

Operaciones CRUD desde mi aplicación de consola

Configurando mi entorno de Cosmos DB

Mi cliente .NET para Cosmos DB

Despliegue de datos con Power BI

Servicios Web y Móviles

Servicios Web y Móviles en Azure

¿Qué son las Azure Web Apps?

¿Por qué utilizar Web Apps?

Características y herramientas principales de Web Apps

Acceso y control de archivos en una Web App por FTP

Creando un sitio web estático con una plantilla HTML

Crea una web app y publicándola desde GitHub

Escalando mi aplicación web desde terminal

¿Qué son las Mobile Apps? y ¿Por qué utilizar Mobile Apps?

¿Cómo funcionan las Mobile Apps?

Cómo crear una Mobile App

Configurando tablas simples en mi Mobile App

Ejemplos de aplicaciones conectadas a mi Mobile App

Editando mi información desde un cliente

Utilizando el API REST de Mobile Apps

Crear mi API con ASP.NET desde Visual Studio

Publicar mi aplicación en Azure

Agregando un cliente para una API REST en mi proyecto

¿Qué son las Logic Apps de Azure? y Conectores en Logic Apps

Flujo de trabajo en Logic Apps

Creando tu primera Logic App

Instala las herramientas de Logic Apps en Visual Studio

Crea y despliega tu Logic App desde Visual Studio