Basically, steps allow you to install Docker client in Windows, setup a Linux host VM in Azure and finally setup a Windows docker host VM in Azure.

Of course, you could arrive at these steps looking here and there. What I'm doing here is to outline the steps I followed in a single place.

Suggestions welcome.

First comes the Docker Windows Client installation:

• install Docker Windows client

from https://chocolatey.org/

@powershell -NoProfile -ExecutionPolicy Bypass -Command `

"iex ((new-object net.webclient).DownloadString('https://chocolatey.org/install.ps1'))" && SET PATH=%PATH%;%ALLUSERSPROFILE%\chocolatey\bin

from https://chocolatey.org/packages/docker
choco install docker

• install openssl client on Windows

https://slproweb.com/products/Win32OpenSSL.html

Next in line is the creation of the Docker Linux Host on Azure:

• create Azure Linux VM docker engine host

create an Ubuntu 14.04 Linux VM in the Azure Portal.

• install docker in the host

https://docs.docker.com/installation/ubuntulinux/#installation

• protect Docker in the Linux host

https://docs.docker.com/articles/https/
Copy ca.pem, cert.pem and key.pem to Windows client's %USERPROFILE%\.docker

• check communication between Docker client and Linux host

docker --tls -H tcp://<Linux Docker host FQDN, *.cloudapp.net>:4243 info

• have some fun

set DOCKER_HOST=tcp://<Linux Docker host FQDN, *.cloudapp.net>:4243

set DOCKER_TLS_VERIFY=TRUE

docker run ubuntu:14.04 /bin/echo 'Hello world'
docker run -t -i /bin/bash
docker run -d ubuntu:14.04 /bin/sh -c "while true; do echo hello world; sleep 1; done"
docker ps
docker logs <id>
docker stop <id>
docker ps
docker version (notice Windows client & Linux server)

• Host a web app on the Docker Linux Host

docker run -d -P training/webapp python app.py
docker logs <id>
<open endpoint in Azure, same public & private ports>
docker run -d -p <endpoint>:5000 training/webapp python app.py
navigate to https://<Linux Docker host FQDN, *.cloudapp.net>:<endpoint>/

Finally, we create the Windows Docker Host on Azure, a Windows Server 2016 Technical Preview version.

For this part, we could create this VM manually, configure its endpoints and other plumbing.

But, Visual Studio provides a better experience by allowing to create a new host from the "Publish..." dialog (announcement here).

• publish web app to Windows container, creating the Windows container VM host in the process

install https://www.microsoft.com/en-us/download/details.aspx?id=48738
install https://visualstudiogallery.msdn.microsoft.com/0f5b2caa-ea00-41c8-b8a2-058c7da0b3e4

create a new MVC app

publish project to Docker Container option, create new VM

• connect to Windows Server 2016 docker host

set DOCKER_HOST=tcp://<Windows Docker host FQDN, *.cloudapp.net>:2376
set DOCKER_TLS_VERIFY=FALSE
copy Windows certs to %USERPROFILE%\.docker\
docker ps

Appendix - Interesting Links

https://msdn.microsoft.com/virtualization/windowscontainers/containers_welcome

https://weblogs.asp.net/scottgu/announcing-windows-server-2016-containers-preview

https://msopentech.com/blog/2014/08/15/getting_started_docker_on_microsoft_azure/

https://azure.microsoft.com/en-us/blog/docker-client-for-windows-is-now-available/

https://docs.docker.com/windows/started/

https://docs.docker.com/installation/windows/ (this is for creating a Linux Container Host on top of virtualbox in Windows)

https://azure.microsoft.com/en-us/documentation/articles/virtual-machines-docker-swarm/

https://docs.docker.com/installation/ubuntulinux/#installation (same as above; for Docker installation on the Ubuntu 14.04 created in Azure)

https://docs.docker.com/articles/https/ (for protecting the Docker endpoints)

https://msdn.microsoft.com/virtualization/windowscontainers/quick_start/manage_docker (interesting, but it doesn't include how to manage the Windows Docker Host from the Windows Docker client)

https://msdn.microsoft.com/virtualization/windowscontainers/about/work_in_progress (important, since there is stuff you can't do - yet)

https://msdn.microsoft.com/en-us/library/azure/mt125409.aspx

https://blogs.msdn.com/b/stevelasker/archive/2015/08/24/why-doesn-t-docker-tools-for-visual-studio-2015-show-the-new-button.aspx (I hit this issue, and installing the right versions was the solution)

There may be a more elegant way to accomplish this, but the way I found was to

• go to customize the entity's form
• configure Tab to open when the form opens
• add jQuery to the form's libraries list.
• put the following code in a web resource and add that web resource to the form's libraries list:

function EnforceSingleNote() {
    EnforceSingleNoteImpl();
    setInterval("EnforceSingleNoteImpl()", 500);
}

function EnforceSingleNoteImpl() {
    var notesInput = $(document.getElementById('notescontrol').contentWindow.document.getElementById('noteTextInput-create'));
    var notesContainer = notesInput.closest('.notesContainerScrollDiv');
    var nAttachments = notesContainer.find('.attachment').length;
    var notesTextBoxDivs = notesContainer.find('.notesTextBoxDiv');
    if (nAttachments > 0 && notesTextBoxDivs.length > 0) {
        notesTextBoxDivs.hide();
    }
    var notesTextCreate = notesContainer.find('.ms-crm-Note-Text-create');
    if (nAttachments > 0 && notesTextCreate.length > 0) {
        notesTextCreate.hide();
    }
}

• add an OnLoad event for the Notes control pointing to the EnforceSingleNote function in the web resource created before.

Basically, once every half a second, it checks whether there’s a note with an attachment. If there is, then it hides de controls where user can enter a new note.

You may be wondering why setInterval() instead of setTimeout(). Well, when you add a file, Dynamics creates on the fly a new “Enter a Note” textarea. The click handler needs to be set to that new textarea, too. Running this code once every second should be enough, and its perf hit should be minimal.

The Update-SPSolution cmdlet upgrades a deployed SharePoint solution in the farm. Use this cmdlet only if a new solution contains the same set of files and features as the deployed solution. If files and features are different, the solution must be retracted and redeployed by using the Uninstall-SPSolution and Install-SPSolution cmdlets, respectively.

Given that Update-SPSolution is way more efficient than the alternative, it pays to see whether it can be leveraged.

So here is a PowerShell script that takes the full path of a .wsp file and a SPSolution, if it exists already in SharePoint, and compares one against the other to determine whether it is possible to get away by updating only instead of uninstalling, removing, adding and installing.

As you can see, it makes use of expand.exe to open the .wsp (cab) file. Therefore it assumes a specific format of its output. (Could be clearly made more robust by replacing expand.exe’s call with unpacking routine.)

function Get-WSPFileNames([string]$fullPathWSP)

{

    [string[]]$e = & expand.exe -D $fullPathWSP

    $f = [System.Array]::CreateInstance([object], $e.Length - 5)

    [System.Array]::Copy($e, 3, $f, 0, $e.Length - 5)

    $f

}

function Compare-WSPFileNames([string[]]$f1, [string[]]$f2)

{

    if($f1.Length -ne $f2.Length)

    {

        throw "Arrays expected to have the same length."

    }

    for($i = 0; $i -lt $f1.Length; $i++)

    {

        $eq = $f1[0].Split(' ')[$f1[0].Split(' ').Length -1] -eq $f2[0].Split(' ')[$f2[0].Split(' ').Length -1]

        if(!$eq)

        {

            return $false

        }

    }

    return $true

}

function CompareWSPFiles([string]$fullPathWSP1, [string]$fullPathWSP2)

{   

    # read WSP's

    $f1 = Get-WSPFileNames $fullPathWSP1

    $f2 = Get-WSPFileNames $fullPathWSP2

    # number of files

    if($f1.Length -ne $f2.Length)

    {

        return $false

    }

    # files

    if(-not (Compare-WSPFileNames $f1 $f2))

    {

        return $false

    }

    # seems they are same

    return $true

}

function CompareWSP($fullPathWSP, $solution)

{

    if($solution -eq $null -or !$solution.Deployed)

    {

        return $false

    }

    $tmp = [System.IO.Path]::GetTempFileName()

    $solution.SolutionFile.SaveAs($tmp)

    $same = CompareWSPFiles $fullPathWSP $tmp

    return $same

}

function CanUpdateSolution($fullPathWSP, $solution)

{

    return CompareWSP $fullPathWSP $solution

}

For more info, go here.

1. Creating Prototype Projects or Items

First of all, create the piece (project or item) that resembles the thing you want to get created starting from the template we are going to create.

That’s simply like

Then, export the template (we are going to use the exported template as a shortcut to build our Visual Studio template package):

You can also start from an existing project you consider suitable as a starting point.

Now, depending on whether a project or item template is going to be created, follow the appropriate instructions for Project or Item Templates below.

2. Creating Visual Studio Project Templates

Choose Project template,

Then complete desired data and make sure that template is NOT imported into Visual Studio, and an explorer windows is opened in the output files folder:

Keep that window opened:

The generated template is a project template, and as such, it includes all the files of the prototype project. Regardless, we will be using it as a starting point for both Item and Project templates, because it is easier to remove items than adding them manually if we had exported as an item template.

3. Creating Template Project

Time to create our template project. Go to File | New | Project…, then choose the highlighted options in the picture , plus an appropriate name for the template:

Next step is to delete all the files from the just generated project. Select and delete them all:

Go to the template .zip generated before, select those files, copy them,

Then navigate to the project template’s folder and paste them:

To add files into the project template (that is, to the project whose files we deleted before), go to Visual Studio, click on “Show All Files”, select the files copied from the .zip and include them in the project:

Now, delete those files that we are not interested to include in the project (remember, we started from an Project template export, therefore it may include extra items we may not want to be part in the case of an item template).

Then, select all files but the .vstemplate, and set their Build Action to “Content”:

Select the .vstemplate and select its Build Action to “VSTemplate”:

As a verification step, build the project. You should end up with a Visual Studio template’s .zip file:

4. Customizing Template Files

Now, it’s time to customize the files in the template project.

.vstemplate

The .vstemplate file defines the attributes of the template, plus where the files will be copied when an item is created based on the template, among other things. Customizations are made based on the VSTemplate element schema here: https://msdn.microsoft.com/en-us/library/31cdwx28(v=vs.100).aspx

Main things to customize in this file are:

- Name, Description, etc: TemplateData

- Template type: <VSTemplate … Type="Item"> or <VSTemplate … Type="Project">, depending on the type of template being created.

- ProjectItem’s to be created in the project that adds this item: <ProjectItem ReplaceParameters="true" TargetFileName="$fileinputname$\Elements.xml">Elements.xml</ProjectItem>

o Beware that the ReplaceParameters attribute both controls whether parameters are replaced in the file and in the TargetFileName attribute.

- References to be added to the project that adds this item: References

Couple tips here:

- Try to not use folders in here, <ProjectItem …>NO FOLDER HERE</ProjectItem>, because it creates that folder’s name in the project that is adding the item.

- Different .vstemplate’s files that are referenced from the same .vsixmanifest must be named differently. Otherwise, last one added wins and that’s the only one that shows up.

.csproj

To customize the .csproj file (the .csproj that defines the template project) right click on the template project, unload the project,

Then edit the project,

Main things to customize in this file are:

- Folder in which templates will appear in the “New project” or “Add new item” dialogs: <VSTemplate …>

<OutputSubPath>My Company\SharePoint 2010</OutputSubPath>

<SubType>Designer</SubType>

</VSTemplate>

Content Files

The files that are generated when an item or project is created are those that were referenced as ProjectItem in the .vstemplate file.

As we saw it, those files were marked as Content, and ReplaceParameters="true" was set for them.

That implies that Visual Studio will generate those files replacing parameters specified in here: https://msdn.microsoft.com/en-us/library/eehb4faa(VS.80).aspx

What to customize in each content file, is up to you. You can go from hard-coding namespaces, item names, classes etc, to, more recommended, customize those items so newly created project or item gets along well with other items and projects in the solution.

Typically, these are the parameters that are to be used for this task:

- $safeitemname$

- $safeprojectname$

- $rootnamespace$

- $GUIDN$ (for ex. $GUID1$, $GUID2$, etc)

5. Creating Visual Studio Package Project

Finally, it’s time to create the project that generates de Visual Studio extension that imports the templates to Visual Studio.

To do that, first create a VSIX solution:

In order to make sure VSIX and its dependencies build correctly, we are going to add the existing template project to the extension project. To do so, right click on the extension solution and add the existing project,

In the extension solution, double-click the manifest, so designer opens, and click “Add Content” on that designer view,

Now reference the template project added just added to the solution, referencing the right project and its right type (Project or Item Template, whatever corresponds):

As a verification step, build the solution, you should see have a .vsix being generated after its dependency project:

6. Debugging

When a extension project is opened, and debugging is started (Debug | Continue, or F5), Visual Studio launches an instance of itself but called “Experimental Instance”,

This allows debbuging of components that run in Visual Studio, as extensions or add-ins.

We need now to check whether the template is actually available. So go to create a new project and see if it’s there:

Use the template by creating a project or adding a new item, depending on the template type to be verified, and check whether it is correct or needs to be fixed.

7. Installing the Extension

Now the the extension was verified, it’s time to install it. Execute the .vsix file from an Administrator command prompt, then when prompted, install,

And make sure it installed correctly, and restart Visual Studio,

Launch Visual Studio again and in Tools | Extension Manager…, you should see the extension being installed,

Now, you are ready to use the templates in Visual Studio, not only in an Experimental Instance of it.

Here’s the scenario: a user navigates to a site whose homepage includes a link to the SharePoint 2010 site. Goal is, user gets into SharePoint 2010 site with no credentials prompt. Both source and destination sites use SQL as the membership repository.

Easy, right? First implementation was with an http module, getting the SQL user from the cookie user brings when coming from the source site, and calling SetAuthCookie(that username). With some tricks, like figuring out that username has to be on the form of "0#.f|membershipprovider-name|username", user got into the site.

But later on, some problems surfaced,

• user could not logout correctly,
• authorization issues i.e., users not being able to access some resources they were supposed to.

So I set out to investigate, and first thing I found  is that cookie generated by SetAuthCookie() (.ASPXAUTH) was different that of the default one you get when logged into SharePoint 2010 out of the box (FedAuth). Luckily, found the reason of this in this great article from the great Steve. That is

• In SharePoint 2010, FBA users are claims users, therefore
• SetAuthCookie() doesn’t do anymore.

Let’s now outline the solution. We need to pieces here to make this work

• a http module that, if it sees an cookie that shows user is authenticated, sets cookie for the SharePoint 2010 site and
• a custom membership provider that, if a cookie value comes in place of a password, then validates the user

(BIG warning here – we are passing to the custom membership provider, in the http module, as password the cookie value. This means, mitigations should be put in place in order to prevent users to, for example, put a long cookie value in a custom login page. For example, we could hash the cookie in the http module and verify that hash in the custom membership provider.)

First of all, we need to set the authentication cookie the right way – that is, leveraging SharePoint claims API’s. I chose to do that from an http module’s AuthenticateRequest:

public void Init(HttpApplication context)
{
    context.AuthenticateRequest += new EventHandler(OnAuthenticateRequest);
}

void OnAuthenticateRequest(object sender, EventArgs e)
{
    HttpContext context = HttpContext.Current;
    HttpRequest request = context.Request;
    HttpCookie cookieVal = request.Cookies[Constants.SAPCookieName];
    if (request.IsAuthenticated)
    {
        return;
    }

    if (cookieVal != null && !String.IsNullOrEmpty(cookieVal.Value))
    {
        string username = GetUsernameFromCookie(cookieVal);
        if (!String.IsNullOrEmpty(username))
        {
            SetFBACookie(request, username, cookieVal.Value);
        }
    }
}

private static void SetFBACookie(HttpRequest r, string username, string cookieValue)
{
    using (SPSite s = new SPSite(r.Url.AbsoluteUri))
    {
        SPIisSettings iis = s.WebApplication.IisSettings[SPUrlZone.Default];
        SPFormsAuthenticationProvider fap = iis.FormsClaimsAuthenticationProvider;
        SecurityToken token = SPSecurityContext.SecurityTokenForFormsAuthentication(new Uri(r.Url.GetComponents(UriComponents.Scheme | UriComponents.HostAndPort, UriFormat.Unescaped), UriKind.Absolute), fap.MembershipProvider, fap.RoleProvider, username, cookieValue);
        SPFederationAuthenticationModule fam = SPFederationAuthenticationModule.Current;
        fam.SetPrincipalAndWriteSessionToken(token);
    }
}

Logic here is pretty much simple and, other than replacing SetAuthCookie() by SetFBACookie(), nothing has changed in the http module from 2007 to 2010. Basically, it looks from a cookie and, if a user can be inferred from it, then sets cookie based on it.

Let’s go to the membership provider part. When SecurityTokenForFormsAuthentication(uri, membershipProv, roleProv, user, password) is called, our custom membership provider’s ValidateUser(user, password) will be called. In there, we take the password as the cookie value. If we can infer a user from it, then we validate that user. If not, validation is delegated to whatever base class we choose to inherit from (LdapMembershipProvider, SqlMembershipProvider, etc), or could have chosen a better design by inject it at runtime.

Here’s the main part of the membership provider:

public override bool ValidateUser(string username, string password)
{
    // check parameters
    if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
    {
        return (false);
    }

    // validate we can get user from cookie and equals the user passed in
    string cookieValue = password;
    string userFromCookie = null;
    userFromCookie = GetUsernameFromCookie(cookieValue);
    if (!string.IsNullOrEmpty(userFromCookie) && userFromCookie.Equals(username, StringComparison.OrdinalIgnoreCase))
    {
        return (true);
    }

    return base.ValidateUser(username, password);
}

Now that we have the components, we need to deploy them.

• in the SharePoint 2010 web application’s web.config we are trying to access we need to configure
• the http module
• the membership provider
• in the SecurityTokenServiceApplication IIS site’s web.config we need to configure
• the membership provider

The http module entry looks like this:

<system.webServer>
<modules runAllManagedModulesForAllRequests="true">
...
<add name="MyHttpModule" type="Contoso.Providers.CustomHttpModule, Contoso, Version=1.0.0.0, Culture=neutral, PublicKeyToken=0123456701234567" … />
</modules>

and the membership provider entry looks like this:

<system.web>
<membership ...>
<providers ...>
<add name="MyMembershipProvider” type="Contoso.Providers.CustomMembershipProvider, Contoso, Version=1.0.0.0, Culture=neutral, PublicKeyToken=0123456701234567" … />

Idea is to start the following script and, at the same time, run a Visual Studio load test against that same web app. If everything works well, at the exit of the script you should end up with a Visual Studio profile (.vsp) that you can analyze.

It requires Visual Studio 2010 Performance Tools installed.

#
# VSProfile.ps1
# Sample call: .\VSProfile.ps1 -AppPoolName "SharePoint - 80" -ProfileOutputPath C:\Temp\Profile.vsp -ProfileDurationSeconds 120
#
param($AppPoolName, $ProfileOutputPath, $ProfileDurationSeconds)

# set perf tools dir
$env:perftoolsdir = "$env:ProgramFiles (x86)\Microsoft Visual Studio 10.0\Team Tools\Performance Tools\x64"

# enable sampling
& "$env:perftoolsdir\vsperfclrenv" /sampleon

# get PID of the w3wp process to profile
& "$env:windir\System32\inetsrv\appcmd.exe" list wp | %{ if($_ -match "WP `"(?<pid>\d+).*(applicationPool:$AppPoolName)") { $w3wpid = [System.Int32]::Parse($matches["pid"]) } }
write-host "Will profile process ID $w3wpid"

# attach to that process
& "$env:perftoolsdir\vsperfcmd" /crosssession /start:sample /attach:$w3wpid /output:$ProfileOutputPath

# wait
[System.Threading.Thread]::Sleep([System.Int32]::Parse($ProfileDurationSeconds)*1000)

# detach
& "$env:perftoolsdir\vsperfcmd" /detach:$w3wpid
& "$env:perftoolsdir\vsperfcmd" /shutdown:5

# wait for vsp file to get totally flushed
[System.Threading.Thread]::Sleep(20000)

        public class Post
        {
            public string Title;
            public string Body;
            public DateTime Published;
            public IEnumerable<Comment> Comments;
        }

        public class Comment
        {
            public string Title;
            public string Body;
            public string Author;
            public DateTime Created;
        }

        static IEnumerable<Post> GetBlogPosts()
        {
            // TODO: get blog's site collection's url
            using (SPSite s = new SPSite("https://server/sites/myblog"))
            {
                SPWeb w = s.RootWeb;

                // get posts
                List<Post> posts = new List<Post>();
                SPList pl = w.Lists["posts"];
                SPQuery pq = new SPQuery() { ViewFields = "<FieldRef Name='Title' /><FieldRef Name='Body' /><FieldRef Name='PublishedDate' />" };
                foreach (SPListItem pli in pl.GetItems(pq))
                {
                    // get post
                    posts.Add(new Post() { Body = (string)pli["Body"], Title = (string)pli["Title"], Published = (DateTime)pli["PublishedDate"], Comments = new List<Comment>() });
                }

                // get comments
                SPList cl = w.Lists["comments"];
                SPQuery cq = new SPQuery() { ViewFields = "<FieldRef Name='Title' /><FieldRef Name='Body' /><FieldRef Name='Author' /><FieldRef Name='Created' /><FieldRef Name='PostTitle' />" };
                foreach (SPListItem cli in cl.GetItems(cq))
                {
                    SPFieldLookupValue plookup = new SPFieldLookupValue((string)cli["PostTitle"]);
                    (from Post p in posts where p.Title == plookup.LookupValue select p).FirstOrDefault<Post>().Comments.Add(new Comment() { Body = (string)cli["Body"], Title = (string)cli["Title"], Author = (string)cli["Author"], Created = (DateTime)cli["Created"] });
                }

                // return
                return (posts);
            }
        }

A typical practice for performance is to add a revision tag (e.g., “file.js?rev=123”) to .js files so a new build, hence a new revision, brings the file to the browser cache.

Tried doing that with ScriptLink’s? No way.

Issue is, due to the processing ScriptLink goes through, we cannot add revision to those files. Say a resulting line is

                <SharePoint:ScriptLink language="javascript" name="core.js?rev=634580691801235029" OnDemand="true" runat="server" />

it gonna fail here (from Reflector)

internal static string ComputeFileHash(string filePath)
{
    FileStream stream = null;
    string str = null;
    try
    {
        new FileIOPermission(FileIOPermissionAccess.Read, filePath).Assert(); <<<<<<<<<<<<<<<<<
        using (SecurityContext.RevertToSelf())
        {
            try
            {
                stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
                str = ComputeStreamHash(stream);
            }
            finally
            {
                if (stream != null)
                {
                    stream.Close();
                }
            }
            return str;
        }
    }
    catch
    {
        throw;
    }
    return str;
}

with a stack like this:

System.ArgumentException: Illegal characters in path.  
System.Security.Permissions.FileIOPermission.HasIllegalCharacters(String[] str)   
System.Security.Permissions.FileIOPermission.AddPathList(FileIOPermissionAccess access, AccessControlActions control, String[] pathListOrig, Boolean checkForDuplicates, Boolean needFullPath, Boolean copyPathList)   
System.Security.Permissions.FileIOPermission..ctor(FileIOPermissionAccess access, String path)   
Microsoft.SharePoint.Utilities.SPUtility.ComputeFileHash(String filePath)   
Microsoft.SharePoint.Utilities.SPUtility.ComputeFileHashForLocalizedLayoutsUrl(Int32 lcidUI, String name, Boolean& fUseThreadCulture)   
Microsoft.SharePoint.Utilities.SPUtility.MakeBrowserCacheSafeLayoutsUrl(String name, Boolean localizable)   
Microsoft.SharePoint.WebControls.ScriptLink.ScriptLinkInfo.ToScriptUrl(Page page)   
Microsoft.SharePoint.WebControls.ScriptLink.ScriptLinkInfo.ToScriptBlock(Page page)   
Microsoft.SharePoint.WebControls.ScriptLink.RenderScriptBlock(Page page, Boolean afterUI)   
Microsoft.SharePoint.WebControls.ScriptLink.Render(HtmlTextWriter writer)   

Local repro,

                string s = @"c:\blah\" + CultureInfo.CurrentCulture.LCID.ToString(CultureInfo.InvariantCulture) + "/" + "core.js?rev=123";
                FileIOPermission fp = new FileIOPermission(FileIOPermissionAccess.Append, s);

So, stick with <script> elements if need this performance trick. Another workaround is to keep using ScriptLink but on files deployed under /_layouts/, in which case this codepath is not traversed.

A client recently hit the issue described in this post, SocialCommentWebPart Title property not working.

Basically, the Title set in the person.aspx to the SocialCommentWebPart is not being honored e.g., <SPSWC:SocialCommentWebPart Title="New Title" …>

One workaround I found is to edit the web part in shared mode and set its title. Because this was needed to be configured during deployment, I wrote the following snippet:

$s = new-object Microsoft.SharePoint.SPSite("https://server/sites/mysitehost")
$page = $s.RootWeb.GetFile("person.aspx")
if($page.CheckOutType -eq 'None')
{
  $page.CheckOut()
}
$wpm = $web.GetLimitedWebPartManager("person.aspx", [System.Web.UI.WebControls.WebParts.PersonalizationScope]::Shared)
$wp = $null
$wpm.WebParts | where {$_.WebBrowsableObject.GetType().Name -eq 'SocialCommentWebPart'} | % {$wp = $_}
$wp.Title = "Nuevo titulo"
$wpm.SaveChanges($wp)
$page.CheckIn("Title Changed")
$s.Close()

Here’s some code for doing what the title states. It deletes whatever is there, then adds a couple of global and current navigation nodes respectively.

string siteUrl = "https://server/sites/blank/default.aspx";
using (SPSite site = new SPSite(siteUrl))
{
    PublishingWeb pw = PublishingWeb.GetPublishingWeb(site.RootWeb);
    int count = pw.Navigation.GlobalNavigationNodes.Count;
    for (int i = 0; i < count ; i++)
    {
        pw.Navigation.GlobalNavigationNodes[0].Delete();
    }
    SPNavigationNode prev;
    prev = pw.Navigation.GlobalNavigationNodes.AddAsFirst(new SPNavigationNode("Mi Sitio", siteUrl));
    pw.Navigation.GlobalNavigationNodes.Add(new SPNavigationNode("Mi Perfil", siteUrl), prev);
    count = pw.Navigation.CurrentNavigationNodes.Count;
    for (int i = 0; i < count; i++)
    {
        pw.Navigation.CurrentNavigationNodes[0].Delete();
    }
    prev = pw.Navigation.CurrentNavigationNodes.AddAsFirst(new SPNavigationNode("Información", siteUrl));
    pw.Navigation.CurrentNavigationNodes.Add(new SPNavigationNode("Sobre Mí", siteUrl), prev);
    pw.Update();
}

This translates into this in the UI: