PageRenderTime 49ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 0ms

/articles/service-fabric/service-fabric-cluster-creation-via-visual-studio.md

https://gitlab.com/yeah568/azure-content
Markdown | 128 lines | 97 code | 31 blank | 0 comment | 0 complexity | 68a83310ac1e6a4499d1ccf4d974bc4e MD5 | raw file
    

  1. <properties
    2. 

  2.    pageTitle="Setting up a Service Fabric cluster using Visual Studio | Microsoft Azure"
    3. 

  3.    description="Describes how to set up a Service Fabric cluster by using Azure Resource Manager (ARM) template created by an Azure Resource Group project in Visual Studio"
    4. 

  4.    services="service-fabric"
    5. 

  5.    documentationCenter=".net"
    6. 

  6.    authors="karolz-ms"
    7. 

  7.    manager="adegeo"
    8. 

  8.    editor=""/>
    9. 

  9. 

  10. <tags
    11. 

  11.    ms.service="service-fabric"
    12. 

  12.    ms.devlang="dotNet"
    13. 

  13.    ms.topic="article"
    14. 

  14.    ms.tgt_pltfrm="NA"
    15. 

  15.    ms.workload="NA"
    16. 

  16.    ms.date="06/27/2016"
    17. 

  17.    ms.author="karolz@microsoft.com"/>
    18. 

  18. 

  19. # Set up a Service Fabric cluster by using Visual Studio
    20. 

  20. This article describes how to set up an Azure Service Fabric cluster by using Visual Studio and an Azure Resource Manager (ARM) template. We will use a Visual Studio Azure resource group project to create the template. After the template has been created, it can be deployed directly to Azure from Visual Studio, but it can also be used from a script or as part of continuous integration (CI) facility.
    21. 

  21. 

  22. ## Create a Service Fabric cluster template by using an Azure resource group project
    23. 

  23. To get started, open Visual Studio and create an Azure resource group project (it is available in the **Cloud** folder):
    24. 

  24. 

  25. ![New Project dialog with Azure Resource Group project selected][1]
    26. 

  26. 

  27. You can create a new Visual Studio solution for this project or add it to an existing solution.
    28. 

  28. 

  29. >[AZURE.NOTE] If you do not see the Azure resource group project under the Cloud node, you do not have the Azure SDK installed. Launch Web Platform Installer ([install it now](http://www.microsoft.com/web/downloads/platform.aspx) if you have not already), and then search for "Azure SDK for .NET" and install the version that is compatible with your version of Visual Studio.
    30. 

  30. 

  31. After you hit the OK button, Visual Studio will ask you to select the Resource Manager template you want to create:
    32. 

  32. 

  33. ![Select Azure Template dialog with Service Fabric Cluster template selected][2]
    34. 

  34. 

  35. Select the Service Fabric Cluster template and hit the OK button again. The project and the Resource Manager template have now been created.
    36. 

  36. 

  37. ## Prepare the template for deployment
    38. 

  38. Before the template is deployed to create the cluster, you must provide values for the required template parameters. These parameter values are read from the `ServiceFabricCluster.parameters.json` file, which is in the `Templates` folder of the resource group project. Open the file and provide the following values:
    39. 

  39. 

  40. |Parameter name           |Description|
    41. 

  41. |-----------------------  |--------------------------|
    42. 

  42. |adminUserName            |The name of the administrator account for Service Fabric machines (nodes).|
    43. 

  43. |certificateThumbprint    |The thumbprint of the certificate that will secure the cluster.|
    44. 

  44. |sourceVaultResourceId    |The *resource ID* of the key vault where the certificate that secures the cluster is stored.|
    45. 

  45. |certificateUrlValue      |The URL of the cluster security certificate.|
    46. 

  46. 

  47. The Visual Studio Service Fabric Resource Manager template creates a secure cluster that is protected by a certificate. This certificate is identified by the last three template parameters (`certificateThumbprint`, `sourceVaultValue`, and `certificateUrlValue`), and it must exist in an **Azure Key Vault**. For more information on how to create the cluster security certificate, see [Service Fabric cluster security scenarios](service-fabric-cluster-security.md#x509-certificates-and-service-fabric) article.
    48. 

  48. 

  49. ## Optional: change the cluster name
    50. 

  50. Every Service Fabric cluster has a name. When a Fabric cluster is created in Azure, cluster name determines (together with the Azure region) the Domain Name System (DNS) name for the cluster. For example, if you name your cluster `myBigCluster`, and the location (Azure region) of the resource group that will host the new cluster is East US, the DNS name of the cluster will be `myBigCluster.eastus.cloudapp.azure.com`.
    51. 

  51. 

  52. By default the cluster name is generated automatically and made unique by attaching a random suffix to a "cluster" prefix. This makes it very easy to use the template as part of a **continuous integration** (CI) system. If you want to use a specific name for your cluster, one that is meaningful to you, set the value of the `clusterName` variable in the Resource Manager template file (`ServiceFabricCluster.json`) to your chosen name. It is the first variable defined in that file.
    53. 

  53. 

  54. ## Optional: add public application ports
    55. 

  55. You may also want to change the public application ports for the cluster before you deploy it. By default, the template opens up just two public TCP ports (80 and 8081). If you need more for your applications, modify the Azure Load Balancer definition in the template. The definition is stored in the main template file (`ServiceFabricCluster.json`). Open that file and search for `loadBalancedAppPort`. You will notice that each port is associated with three artifacts:
    56. 

  56. 

  57. 1. A template variable that defines the TCP port value for the port:
    58. 

  58. 

  59. 	```json
    60. 

  60. 	"loadBalancedAppPort1": "80"
    61. 

  61. 	```
    62. 

  62. 

  63. 2. A *probe* that defines how frequently and for how long the Azure load balancer will attempt to use a specific Service Fabric node before failing over to another one. The probes are part of the Load Balancer resource. Here is the probe definition for the first default application port:
    64. 

  64. 

  65. 	```json
    66. 

  66. 	{
    67. 

  67.         "name": "AppPortProbe1",
    68. 

  68.         "properties": {
    69. 

  69.             "intervalInSeconds": 5,
    70. 

  70.             "numberOfProbes": 2,
    71. 

  71.             "port": "[variables('loadBalancedAppPort1')]",
    72. 

  72.             "protocol": "Tcp"
    73. 

  73.         }
    74. 

  74.     }
    75. 

  75. 	```
    76. 

  76. 

  77. 3. A *load-balancing rule* that ties together the port and the probe, which enables load balancing across a set of Service Fabric cluster nodes:
    78. 

  78. 

  79.     ```json
    80. 

  80. 	{
    81. 

  81. 	    "name": "AppPortLBRule1",
    82. 

  82. 	    "properties": {
    83. 

  83. 	        "backendAddressPool": {
    84. 

  84. 	            "id": "[variables('lbPoolID0')]"
    85. 

  85. 	        },
    86. 

  86. 	        "backendPort": "[variables('loadBalancedAppPort1')]",
    87. 

  87. 	        "enableFloatingIP": false,
    88. 

  88. 	        "frontendIPConfiguration": {
    89. 

  89. 	            "id": "[variables('lbIPConfig0')]"
    90. 

  90. 	        },
    91. 

  91. 	        "frontendPort": "[variables('loadBalancedAppPort1')]",
    92. 

  92. 	        "idleTimeoutInMinutes": 5,
    93. 

  93. 	        "probe": {
    94. 

  94. 	            "id": "[concat(variables('lbID0'),'/probes/AppPortProbe1')]"
    95. 

  95. 	        },
    96. 

  96. 	        "protocol": "Tcp"
    97. 

  97. 	    }
    98. 

  98. 	}
    99. 

  99.     ```
    100. 

  100. If the applications that you plan to deploy to the cluster need more ports, you can add them by creating additional probe and load-balancing rule definitions. For more information on how to work with Azure Load Balancer through Resource Manager templates, see [Get started creating an internal load balancer using a template](../load-balancer/load-balancer-get-started-ilb-arm-template.md).
    101. 

  101. 

  102. ## Deploy the template by using Visual Studio
    103. 

  103. After you have saved all the required parameter values in the`ServiceFabricCluster.param.dev.json` file, you are ready to deploy the template and create your Service Fabric cluster. Right-click the resource group project in Visual Studio Solution Explorer and choose **Deploy | New Deployment...**. Visual Studio will show the **Deploy to Resource Group** dialog box, asking you to authenticate to Azure, if necessary:
    104. 

  104. 

  105. ![Deploy to Resource Group dialog][3]
    106. 

  106. 

  107. The dialog box lets you choose an existing Resource Manager resource group for the cluster and gives you the option to create a new one. It normally makes sense to use a separate resource group for a Service Fabric cluster.
    108. 

  108. 

  109. After you hit the Deploy button, Visual Studio will prompt you to confirm the template parameter values. Hit the **Save** button. One parameter does not have a persisted value: the administrative account password for the cluster. You will need to provide a password value when Visual Studio prompts you for one.
    110. 

  110. 

  111. >[AZURE.NOTE] If PowerShell was never used to administer Azure from the machine that you are using now, you will need to do a little housekeeping.
    112. 

  112. >1. Enable PowerShell scripting by running the [`Set-ExecutionPolicy`](https://technet.microsoft.com/library/hh849812.aspx) command. For development machines, "unrestricted" policy is usually acceptable.
    113. 

  113. >2. Decide whether to allow diagnostic data collection from Azure PowerShell commands, and run [`Enable-AzureRmDataCollection`](https://msdn.microsoft.com/library/mt619303.aspx) or [`Disable-AzureRmDataCollection`](https://msdn.microsoft.com/library/mt619236.aspx) as necessary. This will avoid unnecessary prompts during template deployment.
    114. 

  114. 

  115. You can monitor the progress of the deployment process in the Visual Studio output window. Once the template deployment is completed, your new cluster is ready to use!
    116. 

  116. 

  117. If there are any errors, go to the [Azure portal](https://portal.azure.com/) and open the resource group that you deployed to. Click **All settings**, then click **Deployments** on the settings blade. A failed resource-group deployment will leave detailed diagnostic information there.
    118. 

  118. 

  119. >[AZURE.NOTE] Service Fabric clusters require a certain number of nodes to be up at all times in order to maintain availability and preserve state - referred to as "maintaining quorum". Consequently, it is typically not safe to shut down all of the machines in the cluster unless you have first performed a [full backup of your state](service-fabric-reliable-services-backup-restore.md).
    120. 

  120. 

  121. ## Next steps
    122. 

  122. - [Learn about setting up Service Fabric cluster using the Azure portal](service-fabric-cluster-creation-via-portal.md)
    123. 

  123. - [Learn how to manage and deploy Service Fabric applications using Visual Studio](service-fabric-manage-application-in-visual-studio.md)
    124. 

  124. 

  125. <!--Image references-->
    126. 

  126. [1]: ./media/service-fabric-cluster-creation-via-visual-studio/azure-resource-group-project-creation.png
    127. 

  127. [2]: ./media/service-fabric-cluster-creation-via-visual-studio/selecting-azure-template.png
    128. 

  128. [3]: ./media/service-fabric-cluster-creation-via-visual-studio/deploy-to-azure.png
    129. 

  129.