En esta entrada veremos una características mas de Windows Azure es precisamente el SQL Services. Los cuales son una suite de características de SQL Server basadas en la nube y ofrecen la posibilidad de procesamiento de consultas de servicios de bases de datos para producir nuevas aplicaciones o integrar el servicio en las ya existentes, ofreciendo flexibilidad, escalabilidad, y por supuesto un desarrollo ágil.
Una autoridad en SQL Data Services es el nivel mas alto en la jerarquía de contenido, dentro de una autoridad se crean Containers y dentro de los Containers se encuentran las Entities.
En la REST API, el nombre de Autoridad corresponde a un nombre de DNS que resuelve una localización de datos, por ejemplo el nombre de autoridad “smithjt1” se resolvería de la siguiente manera.
https://smithjt1.data.database.windows.net/v1/
Ahora bien, para crear un nombre de Autoridad es necesario crear un proyecto de aplicación de Consola de Windows en Visual Studio, y en el archivo app.config, modificarlo de la siguiente forma.
En el campo de authority ubicamos el nombre de autoridad que necesitemos, este debe de ser único y solo se permiten caracteres alfanuméricos, en el nombre de usuario y password ubicamos los datos de nuestra solución cuando la creamos con el código de invitación de Azure, en un articulo sobre el SDK de Azure, ya escribí algo sobre estos datos y como conseguir los códigos de invitación.
Ahora solo necesitaremos agregar un método a la clase Program.cs, y este seria como el siguiente.
Agregaremos la siguiente clase a nuestra solución.
1: using System;
2: using System.Configuration;
3:
4: public class SsdsConfig
5: {
6: public Uri ServiceUri { get; set; }
7: public string Authority { get; set; }
8: public string Username { get; set; }
9: public string Password { get; set; }
10:
11: /// <summary>
12: /// Generates the appropriate configuration information from the app.config
13: /// settings. Use this to construct the necessary details for credentials
14: /// and http service locations.
15: /// </summary>
16: /// <returns></returns>
17: public static SsdsConfig Create()
18: {
19: return new SsdsConfig
20: {
21: ServiceUri = new Uri(ConfigurationSettings.AppSettings["serviceUri"]),
22: Authority = ConfigurationSettings.AppSettings["authority"],
23: Username = ConfigurationSettings.AppSettings["username"],
24: Password = ConfigurationSettings.AppSettings["password"]
25: };
26: }
27:
28: /// <summary>
29: /// Get the proper Authority URI based on configuration settings
30: /// </summary>
31: /// <returns></returns>
32: public Uri GetAuthority()
33: {
34: return new Uri(
35: String.Format("https://{0}.{1}/v1/", this.Authority, this.ServiceUri.Host)
36: );
37: }
38:
39: /// <summary>
40: /// Creates a URI for a container based on configuration settings
41: /// </summary>
42: /// <param name="container">container name</param>
43: /// <returns></returns>
44: public Uri GetContainer(string container)
45: {
46: return new Uri(
47: String.Format("{0}{1}", this.GetAuthority(), container)
48: );
49: }
50:
51: /// <summary>
52: /// Creates a URI for an entity based on configuration settings
53: /// </summary>
54: /// <param name="container">container name</param>
55: /// <param name="entityId">entity ID</param>
56: /// <returns></returns>
57: public Uri GetEntity(string container, string entityId)
58: {
59: return new Uri(
60: String.Format("{0}{1}/{2}", this.GetAuthority(), container, entityId)
61: );
62: }
63: }
Después a nuestros método principal agregaremos el siguiente código.
Finalmente lo que haremos será realizar una petición HTTP para crear nuestro nombre de autoridad usando el REST API. Para esto agregamos el siguiente código a al método CreateAuthority() después del Console.WriteLine(). Quedando de la siguiente manera.
1: public static void CreateAuthority(SsdsConfig config)
2: {
3: //create xml to represent the HTTP payload
4: var xml = new XElement(Constants.ns + "Authority",
5: new XElement(Constants.ns + "Id", config.Authority)
6: );
7:
8: Console.WriteLine(xml);
9: var request = HttpWebRequest.Create(config.ServiceUri);
10:
11: request.ContentType = "application/x-ssds+xml";
12: request.Method = "POST";
13:
14: string authToken = String.Format("{0}:{1}", config.Username, config.Password);
15: byte[] credentialBuffer = new UTF8Encoding().GetBytes(authToken);
16:
17: request.Headers.Add(HttpRequestHeader.Authorization,
18: "Basic " + Convert.ToBase64String(credentialBuffer));
19:
20: var bytes = new UTF8Encoding().GetBytes(xml.ToString());
21:
22: using (var stream = request.GetRequestStream())
23: {
24: stream.Write(bytes, 0, bytes.Length);
25: }
26:
27: var response = (HttpWebResponse)request.GetResponse();
28: if (response.StatusCode == HttpStatusCode.Created)
29: {
30: Console.WriteLine("Success: {0}", config.GetAuthority());
31: }
32: }
Si compilamos nuestra solución, podremos notar que efectivamente nos crea nuestro nombre autoridad.
Y si visitáramos la url que nuestra aplicación nos ha creado, veremos que justamente se encuentra creado nuestro nombre de Autoridad para empezar a crear contenedores y entidades.
Este sitio al ingresar nos pedirá unas credenciales para autentificarnos las cuales son el nombre de nuestra solución y nuestro password. Aun en esta versión beta de Azure no se permite el acceso de usuarios anónimos a nuestra definición del servicio.
En mi próxima entrada escribiré algo acerca de como crear entidades y contenedores para realizar consultas en LINQ y poder interactuar con SQL Data Services.