The ability to create a virtual machine on demand, whether a standard image or from one you supply, can be very useful. This approach, commonly known as Infrastructure as a Service (IaaS), is what Azure Virtual Machines provides.
To create a VM, you specify which VHD to use and the VM's size. You then pay for the time that the VM is running. You pay by the minute and only while it's running, though there is a minimal storage fee for keeping the VHD available. Azure offers a gallery of stock VHDs (called "images") that contain a bootable operating system to start from. These include Microsoft and partner options, such as Windows Server and Linux, SQL Server, Oracle and many more. You're free to create VHDs and images and then upload them yourself. You can even upload VHDs that contain only data and then access them from your running VMs.
This quite general approach to cloud computing can be used to address many different issues:
In this lab, you will learn how to create virtual machines using different options provided by Azure. You will also add data disks, access them and install VM extensions.
This lab includes the following tasks:
Creating a Virtual Machine using Azure Portal
In this task you will create a Windows virtual machine using an existing image from the Azure Management Portal.
Creating a Virtual Machine using the Cross-Platform Command-Line Interface
In this task you will use the command line cross-platform tools to: configure the subscription in the command line using a publishsettings file, create a Linux virtual machine using an existing image, attach an empty data disk to it, connect to the virtual machine using PuTTY and configure the attached data disk.
Creating a Virtual Machine using PowerShell:
In this task you will use the PowerShell command line to configure the azure subscription using Azure AD, create a Windows virtual machine, attach an empty datadisk to the vm, install a VM Extension, and connect to the vm via a generated rdp file to configure the attached datadisk in the virtual machine.
Creating a Virtual Machine using a Runbook
In this task you will ensure some prerequisites are present like creating an organizational account, create an automation account, create an empty runbook, edit the runbook to create a virtual machine and publish it, create the necessary assets for the runbook execution, start the runbook and once it finishes verify that the vm was created in the portal.
Creating a Virtual Machines with IIS and SQL VM using ARM Templates
In this task you will use ARM template to create one or two Windows Server 2012R2 VM(s) with IIS configured using DSC. It also installs one SQL Server 2014 standard edition VM, a VNET with two subnets, NSG, loader balancer, NATing and probing rules.
This is a long lab which shows how you can perform similar actions using the different tools available, so you can choose which task you want to execute based on the explanations above. It's recommended that you run Creating a Virtual Machine using using the Cross-Platform Command-Line Interface and Creating a Virtual Machine using PowerShell, as these provide a good coverage of many tasks performed on a virtual machine, but you can choose to execute all or the ones that most interest you.
In this task you will create a Virtual Machine in Azure Portal.
Sign in to the Azure Management Portal.
On the Left Side bar, click + NEW and then click on See all.
Creating a VM
Click Compute and then click the Windows Server tile.
Creating a VM - Click Virtual Machines then the Windows Server tile
A new blade opens with the different images available for Windows Server. Find and click Windows Server 2012 R2 Datacenter.
Creating a VM - Select the image to use
In the Windows Server 2012 R2 Datacenter blade, Select 'Resource Manager' from dropdown select a deployment model, and then click Create.
Creating a VM - Click Create to confirm the use of this image
On the Create Virtual Machine blade that opens, enter:
Location: select the location for the virtual machine. (e.g. West US)
Creating a VM - Basic Configuration
Size: select the size of virtual machine needed. (Select See All for checking all sizes and details)
Creating a VM - Types of Sizes
Disk Type: select the disk size. (e.g. Standard/Premium(SSD))
Public IP address: public IP address
Creating a VM - Settings
Summary: virtual machine summary details before you click on create.
Creating a VM - Summary
Note: Premium storage, available for DS-series virtual machines in certain regions. For details, see Premium Storage: High-Performance Storage for Azure Virtual Machine Workloads.
Click OK.
The VM will start being created. You can monitor the creation progress on the Notifications. As this can take a few minutes, this task ends here.
Creating a VM - Monitor progress in the Notifications Hub
Note: After the VM is created, the Virtual Machine blade will open. A pin for the VM (e.g. azureVM) is also added to the Startboard. You can use it to access the VM.
Creating a VM - A pin was created in the Startboard
Once the virtual machine has been created you can attach new or existing data disks to the Virtual Machine. See About Virtual Machine Disks in Azure for more information.
Virtual Machine details after Creation
In this task you will use the Azure Cross-Platform Command-Line Interface (xplat-cli) to create a Linux virtual machine and attach an empty disk to it. After that you will connect to the vm and configure the disk.
You will start by configuring your Azure subscription in the xplat-cli.
While some commands provided by the xplat-cli will work without an Azure subscription, most commands require one. To configure the xplat-cli to work with your subscription, you can either download and use a publish settings file or log in to Azure using an organizational account. When you log in, Azure Active Directory is used to authenticate the credentials.
To help you choose the authentication method most appropriate for your needs, consider the following:
The login method can make it easier to manage access to subscriptions but may disrupt automation, as the credentials may time out and require you to log in again.
The publish settings file method installs a certificate that allows you to perform management tasks for as long as the subscription and the certificate are valid. This method makes it easier to use automation for long-running tasks. After you download and import the information, you don't need to provide it again. However, this method makes it harder to manage access to a subscription since anyone with access to the certificate can manage the subscription.
For more information about authentication and subscription management, see "What's the difference between account-based authentication and certificate-based authentication".
In order to use the publish settings file method, perform the following steps:
Open a Command prompt if there is not already one open, and run the following command to download the publish settings file for your account:
azure account download
This will open your default browser and prompt you to sign in to the Azure Management Portal. After signing in, a .publishsettings
file will be downloaded. Make note of where this file is saved.
Next, import the .publishsettings
file by running the following command, replacing [path to .publishsettings file]
with the path to your .publishsettings
file:
azure account import [path to .publishsettings file]
Note: When you import publish settings, the information to access your Azure subscription is stored in a
.azure
directory located in youruser
directory. Youruser
directory is protected by your operating system; however, it is recommended that you take additional steps to encrypt youruser
directory. You can do so in the following ways:
>
- On Windows, modify the directory properties or use BitLocker.
- On Mac, turn on FileVault for the directory.
- On Ubuntu, use the Encrypted Home directory feature. Other Linux distributions offer equivalent features.
After importing your publish settings, you should delete the .publishsettings
file, as it is no longer required by the Command-Line Tools and presents a security risk as it can be used to gain access to your subscription.
Note: If you prefer using the login method, use the following command:
azure login -u username -p password
Now that you have configured your Azure subscription in the command line you will proceed to create the virtual machine.
From the Command prompt, run the following command to list all the available locations from which you can choose to create a virtual machine. Take note of one of them (e.g.: West US); as you will use it in the following step.
```
azure vm location list
```
To create a new virtual machine based on the b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04-LTS-amd64-server-20140724-en-us-30GB image run the following command. Replace [LINUX-VM-NAME] and [ADMIN-USERNAME] with your desired values for the virtual machine name and administrator user. You can also replace West US by the location you chose in the previous step.
As the command executes it will prompt you to enter the password for the admin user.
azure vm create [LINUX-VM-NAME] b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04-LTS-amd64-server-20140724-en-us-30GB [ADMIN-USERNAME] --location "West US" --ssh
Note 1: The --ssh parameter enables SSH to manage the deployed Linux virtual machine.
Note 2: To list the available images use the following command.
azure vm image list
Note 3: You can specify the blob storage url by specifying the --blob-url parameter to the vm create command. In order to create a storage account use the following steps:
- Replace the [ACCOUNT-NAME] placeholder and execute the following command to create the new storage account. You will be prompted to provide the location where you want to create the storage account. Make sure you provide the same location as you plan to use when creating the virtual machine.
azure storage account create [ACCOUNT-NAME]
- Obtain and take note of the account keys of the new account by executing the following command. Replace the [ACCOUNT-NAME] placeholder with the one used in the previous step.
azure storage account keys list [ACCOUNT-NAME]
- Now, create a new container in the blob storage account by executing the following command, replacing all the placeholders accordingly.
> ```
> azure storage container create [CONTAINER-NAME] --account-name [ACCOUNT-NAME] --account-key [STORAGE-ACCOUNT-KEY]
> ```
> 1. Finally, execute the `azure vm create` command using the _--blob-url_ parameter with the blob url, which will resemble the following: `https://<accountname>.blob.core.windows.net/<containerName>/<the-blob-name.vhd>`.
> ```
> azure vm create [LINUX-VM-NAME] b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04-LTS-amd64-server-20140724-en-us-30GB [ADMIN-USERNAME] --location "West US" --ssh --blob-url https://[ACCOUNT-NAME].blob.core.windows.net/<containerName>/<the-blob-name.vhd>
> ```
>
Once this command finishes creating the virtual machine with no errors, you can proceed to attach an empty data disk to it.

To attach a new 30gb disk to your virtual machine, execute the following command. Replace your-linux-vm with the name of the virtual machine you created.
azure vm disk attach-new [LINUX-VM-NAME] 30
You should get a message resembling the following:
info: Executing command vm disk attach-new
+Getting virtual machines
+Adding Data-Disk
info: vm disk attach-new command OK
To display details about the virtual machine, execute the following command. Replace [LINUX-VM-NAME] with the name of the virtual machine you created. Take note of the DNSName value and make sure that the SSH endpoint exists.
azure vm show [LINUX-VM-NAME]
The output of this command should be similar to the following:
info: Executing command vm show
+Getting virtual machines
data: DNSName "your-linux-vm.cloudapp.net"
data: Location "West US"
data: VMName "your-linux-vm"
data: IPAddress "<IP_ADDRESS>"
data: InstanceStatus "ReadyRole"
data: InstanceSize "Small"
data: Image "b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04_1-LTS-amd64-server-20141125-en-us-30GB"
data: OSDisk hostCaching "ReadWrite"
data: OSDisk name "your-linux-vm-your-linux-vm-0-201501202057370849"
data: OSDisk mediaLink "https://portalvhdsqmqsgyc6l4zl4.blob.core.windows.net/vhds/your-linux-vm-your-linux-vm-2015-01-20.vhd"
data: OSDisk sourceImageName "b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04_1-LTS-amd64-server-20141125-en-us-30GB"
data: OSDisk operatingSystem "Linux"
data: OSDisk iOType "Standard"
data: DataDisks 0 hostCaching "None"
data: DataDisks 0 label "your-linux-vm-your-linux-vm-your-linux-vm42-0"
data: DataDisks 0 name "your-linux-vm-your-linux-vm-0-201501202103240353"
data: DataDisks 0 logicalDiskSizeInGB 30
data: DataDisks 0 mediaLink "https://portalvhdsqmqsgyc6l4zl4.blob.core.windows.net/vhds/your-linux-vm-f539b3ed4be4e5ab.vhd"
data: DataDisks 0 iOType "Standard"
data: ReservedIPName ""
data: VirtualIPAddresses 0 address "<IP_ADDRESS>"
data: VirtualIPAddresses 0 name "your-linux-vmContractContract"
data: VirtualIPAddresses 0 isDnsProgrammed true
data: Network Endpoints 0 localPort 22
data: Network Endpoints 0 name "SSH"
data: Network Endpoints 0 port 22
data: Network Endpoints 0 protocol "tcp"
data: Network Endpoints 0 virtualIPAddress "<IP_ADDRESS>"
data: Network Endpoints 0 enableDirectServerReturn false
info: vm show command OK
To manage the settings of the virtual machine and the applications that run on the machine, you can use an SSH client. You will use the PuTTY program to access the virtual machine.
Note: To do this, you must install an SSH client on the computer that you want to use to access the virtual machine. There are many SSH client programs to choose from, including the following:
- If you are using a computer that is running a Windows operating system, you might want to use an SSH client such as PuTTY. For more information, see PuTTY Download.
- If you are using a computer that is running a Linux operating system, you might want to use an SSH client such as OpenSSH. For more information, see OpenSSH.
Open the PuTTY program.
Note: If you are using a console SSH client, use the following command to log in:
ssh
Enter the DNSName that you collected from the execution of the azure vm show
command in the Host Name input and then click Open.
Opening the connection to the virtual machine in PuTTY
Click Yes in the PuTTY Security Alert dialog box in order to add the server's key to the cache.
Clicking yes to save the key in the cache
Log on to the virtual machine using the administrator user name selected when you created the virtual machine (e.g.: yourVMUsername).
Log on to the virtual machine
You can now work with the virtual machine just as you would with any other server.
Your application may need to store data. To set this up, you attached an empty data disk to the virtual machine.
On Linux, the Resource Disk is typically managed by the Azure Linux Agent and automatically mounted to /mnt/resource (or /mnt on Ubuntu images). However, the data disk might be named according to the kernel such as /dev/sdc
, and users will need to partition, format and mount that resource. You will now learn how to do that. Please see the Azure Linux Agent User Guide for more information.
Note: Don’t store data on the resource disk. This disk provides temporary storage for applications and processes and is used to store unnecessary data such as swap files. Data disks reside in Azure Storage as .vhd files in page blobs and provide storage redundancy to protect your data. For more detail, see About Disks and Images in Azure.
In the SSH window, type the following command:
sudo grep SCSI /var/log/syslog
You can find the identifier of the last data disk that was added in the messages that are displayed, in brackets (e.g. [sdc]).
In the SSH window, type the following command to create a new device:
sudo fdisk /dev/sdc
Executing fdisk in the virtual machine
Note: In this example you may need to use
sudo -i
on some distributions if /sbin or /usr/sbin are not in your$PATH
.
Type n to create a new partition.
Type p to make the partition the primary partition, type 1 to make it the first partition, and then type enter to accept the default values for the first and last sectors.
Type p to see the details about the disk that is being partitioned.
Displaying disk details
Type w to write the settings for the disk.
You must create the file system on the new partition. As an example, type the following command to create the file system:
sudo mkfs -t ext4 /dev/sdc1
Note: Note that SUSE Linux Enterprise 11 systems provide only read-only access for ext4 file systems. For these systems, we recommended formatting the new file system as ext3 rather than ext4.
Create a directory to mount the new file system. As an example, type the following command:
sudo mkdir /datadrive
Type the following command to mount the drive:
sudo mount /dev/sdc1 /datadrive
The data disk is now ready to use as /datadrive.
To ensure the drive is re-mounted after a reboot, it must be added to the /etc/fstab file. In addition, it is highly recommended that the UUID (Universally Unique IDentifier) is used in /etc/fstab to refer to the drive rather than just the device name (i.e. /dev/sdc1). To find the UUID of the new drive you can use the blkid utility:
sudo -i blkid
The output will resemble the following:
/dev/sda1: UUID="11111111-1b1b-1c1c-1d1d-1e1e1e1e1e1e" TYPE="ext4"
/dev/sdb1: UUID="22222222-2b2b-2c2c-2d2d-2e2e2e2e2e2e" TYPE="ext4"
/dev/sdc1: UUID="33333333-3b3b-3c3c-3d3d-3e3e3e3e3e3e" TYPE="ext4"
Note: blkid may not require sudo access in all cases, however, it may be easier to run with
sudo -i
on some distributions if /sbin or /usr/sbin are not in your$PATH
.Caution: Improperly editing the /etc/fstab file could result in an unbootable system. If unsure, please refer to the distribution's documentation for information on how to properly edit this file. It is also recommended that a backup of the /etc/fstab file is created before editing.
Using a text editor, enter the information about the new file system at the end of the /etc/fstab file. In this example we will use the UUID value for the new /dev/sdc1 device that was created in the previous steps, and the mountpoint /datadrive.
UUID=33333333-3b3b-3c3c-3d3d-3e3e3e3e3e3e /datadrive ext4 defaults 1 2
Note 1: On systems based on SUSE Linux you may need to use a slightly different format:
/dev/disk/by-uuid/33333333-3b3b-3c3c-3d3d-3e3e3e3e3e3e / ext3 defaults 1 2
Note 2: You can use the vim text editor in order to perform this steps.
- Execute the following command in order to start the vim editor
sudo vim /etc/fstab
- Type i to enter to INSERT mode and use the arrows to go to the end of the file.
- Type enter and then add the information.
- Type Esc to exit the INSERT mode.
- Type :wq in order to write the file and quit vim.
Note 3: If additional data drives or partitions are created, you will need to enter them into /etc/fstab separately as well.
You can now test that the file system is mounted properly by simply unmounting and then re-mounting the file system, i.e. using the example mount point /datadrive
created in the earlier steps:
sudo umount /datadrive
sudo mount /datadrive
If the second command produces an error, check the /etc/fstab file and make sure the syntax is correct.
Note: Subsequently removing a data disk without editing fstab could cause the VM to fail to boot. If this is a common occurrence, then most distributions provide either the
nofail
and/ornobootwait
fstab options that will allow a system to boot even if the disk is not present. Please consult your distribution's documentation for more information on these parameters.
##Creating a Virtual Machine using Powershell
In this task you will create a virtual machine using PowerShell cmdlets.
In the following steps you will configure your azure subscription in PowerShell, ensure your subscription has a storage account associated with it and will set one if not. You will then set variables with the parameters of the virtual machine that will be created, and continue by creating the virtual machine. You will also learn how to attach a new disk to the virtual machine and how to add a VM Extension to the virtual machine. Finally, you will create a Remote Desktop Protocol file to access the machine and use it to access the machine and initialize the new disk.
You will start by configuring your Azure subscription in Powershell.
As for the xplat-cli, most cmdlets require an Azure subscription to manage your services. There are two ways to provide your subscription information to Windows PowerShell: you can use a management certificate that contains the information or you can sign in to Azure using your Microsoft account or an organizational (work or school) account. When you sign in, Azure Active Directory (Azure AD) authenticates the credentials and returns an access token that lets Azure PowerShell manage your account.
Azure AD is the recommended authentication method since it makes it easier to manage access to a subscription. With the update in version 0.8.6, it enables an automation scenario with Azure AD authentication even when using a work or school account. It works with Azure Resource Manager API as well.
For more information about authentication and subscription management, see "What's the difference between account-based authentication and certificate-based authentication".
To log in using an Azure AD account, follow these instructions:
Open the Microsoft Azure PowerShell console.
Type the following command and hit Enter:
Add-AzureAccount
A dialog box to Sign in to Microsoft Azure will appear. Follow the instructions, typing the email address and password associated with your account when prompted.
Azure authenticates and saves the credential information, and then closes the window. After it does, you will see the following output appear in the console window.
Running the Add-AzureAccount command
Starting from 0.8.6, if you sign in using an organizational account, you can type the following command to bypass the pop up window:
$cred = Get-Credential Add-AzureAccount -Credential $cred
This will prompt the standard Windows PowerShell credential window for you to enter your work or school account user name and password.
If you are using this in an automation script and want to avoid any popup windows, use the following snippet:
$userName = "<your work or school account user name>" $securePassword = ConvertTo-SecureString -String "<your work or school account password>" -AsPlainText -Force $cred = New-Object System.Management.Automation.PSCredential($userName, $securePassword) Add-AzureAccount -Credential $cred
Note: This non-interactive login method only works with an organizational account. An organizational account is a user that is managed by your organization and defined in the Azure Active Directory instance for your organization. If you do not currently have an organizational account you can follow the instructions for Creating a new organizational account to create one.
Now you will ensure your azure subscription has an associated storage account and configure one, if not.

Get-AzureSubscription
The command will produce an output like this:
Get-AzureSubscription output when no Storage Account set
Note the value for SubscriptionName in the output (Free Trial in this case). You will use it to replace the [SUBSCRIPTION-NAME] placeholder in upcoming steps.
Run the following command to get information about the storage account:
Get-AzureStorageAccount
The output produced will look like this:
Get-AzureStorageAccount output
Note the values for the Label and Location properties. You will use them to replace the [STORAGE-ACCOUNT-LABEL] and [STORAGE-ACCOUNT-LOCATION] placeholders in the upcoming steps.
If, like in the image shown a couple of steps above, the command Get-AzureSubscription did not list a value next to CurrentStorageAccountName, run the following snippet to set it. Replace the [SUBSCRIPTION-NAME] and [STORAGE-ACCOUNT-LABEL] placeholders with the values retrieved earlier. Otherwise, skip this step.
Set-AzureSubscription -SubscriptionName "[SUBSCRIPTION-NAME]" -CurrentStorageAccountName [STORAGE-ACCOUNT-LABEL]
This will set the storage account. You can execute the Get-AzureSubscription command and this time, the value set should be listed.
Now you will set the variables that will be used to create the virtual machine.
Execute the snippet below, replacing the [ADMIN-USER-NAME] and [ADMIN-PASSWORD] placeholders with your desired values, and the [STORAGE-ACCOUNT-LOCATION] placeholder with the value retrieved earlier. The location entered should match the storage account location retrieved earlier.
$dclocation = '[STORAGE-ACCOUNT-LOCATION]'
$adminUserName = '[ADMIN-USER-NAME]'
$adminPassword = '[ADMIN-PASSWORD]'
$vmname = 'azureVM'
Select a name for the Cloud Service. As it needs to be unique, you can verify first whether the selected Cloud Service Name exists by running the Test-AzureName command. If this command outputs False, the name is available.
Test-AzureName -Service '[CLOUD-SERVICE-NAME]'
$cloudSvcName = '[CLOUD-SERVICE-NAME]'
Set the image name for your virtual machine to a699494373c04fc0bc8f2bb1389d6106__Windows-Server-2012-Datacenter-201412.01-en.us-127GB.vhd. This corresponds to an image of Windows Server R2 DataCenter.
$image = 'a699494373c04fc0bc8f2bb1389d6106__Windows-Server-2012-Datacenter-201412.01-en.us-127GB.vhd'
Note: You can view the complete list of images available by running the following command:
Get-AzureVMImage | select ImageName
You can choose to create a virtual machine based on a different image. If you choose to create a Linux virtual machine, the command to create the virtual machine will vary slightly.
Now that all variables are set, run the following command to create the virtual machine:
New-AzureQuickVM -AdminUserName $adminUserName -Windows -ServiceName $cloudSvcName -Name $vmname -ImageName $image -Password $adminPassword -Location $dclocation
Note: If you chose to create a Linux image, the command to use is the following:
New-AzureQuickVM -Linux -ServiceName $cloudSvcName -Name $vmname -ImageName $image -LinuxUser $adminUserName -Password $adminPassword -Location $dclocation
The differences reside in the -Linux OS switch and the -LinuxUser switch that replaces the -AdminUserName switch in Windows.
Note 2: Specifying the -Location parameter when calling New-AzureQuickVM or New-AzureVM tells the Cmdlet to attempt to create a cloud service as a container for the virtual machines. Use this option when creating the first virtual machine and omit it when adding new virtual machines to the same cloud service.
Note 3: For more information, visit the New-AzureQuickVM reference page.
The virtual machine is created.
Virtual Machine creation output
You can list all VMs in the Cloud Service by running the following cmdlet:
Get-AzureVM -ServiceName $cloudSvcName
Get-AzureVM output when listing all virtual machines
If you want to enumerate only the details of the virtual machine just created, provide the -Name switch:
Get-AzureVM -ServiceName $cloudSvcName -Name $vmname
Now you will add an empty disk to the virtual machine. Since the virtual machine has already been created, you will need to modify the existing machine. Modifying an existing virtual machine requires retrieving the current settings by calling Get-AzureVM, modifying them, and then calling the Update-AzureVM Cmdlet to save the changes.
Note: It's a best practice to use one or more separate disks to store a virtual machine's data. When you create an Azure virtual machine, it has a disk for the operating system mapped to the C drive and a temporary disk mapped to the D drive. Do not use the D drive to store data. As the name implies, it provides temporary storage only. It offers no redundancy or backup because it doesn't reside in Azure storage.
Execute the following pipe of cmdlets:
Get-AzureVM -Name $vmname -ServiceName $cloudSvcName |
Add-AzureDataDisk -CreateNew -DiskSizeInGB 50 -DiskLabel 'datadisk1' -LUN 2 |
Update-AzureVM
The Get-AzureVM Cmdlet retrieves the virtual machine object and sends it to the PowerShell Pipeline.
The Add-AzureDataDisk Cmdlet with the -CreateNew parameter allows you to dynamically add storage to the virtual machine. In this case you are attaching an unformatted blank VHD of 50 gigabytes. The -LUN parameter tells the order of the device being attached and the optional -MediaLocation parameter can be added to specify the location in storage to keep the new VHDs.
Add-AzureDataDisk also supports the -Import parameter to attach a disk in the disk library and -ImportFrom to attach a pre-existing disk in storage.
Once the Update-AzureVM call has completed, your virtual machine is ready to be used.
Update-AzureVM output after adding a new datadisk

Now you will learn how to add extensions to the virtual machine just created.
Microsoft Azure provides VM Extensions built by both Microsoft and trusted third-party providers to enable security, runtime, debugging, management, and other features you can take advantage of to increase your productivity with Azure Virtual Machines.
For more details see [Azure VM Extensions and Features](https://msdn.microsoft.com/en-us/library/azure/dn606311.aspx).
The **Azure Virtual Machine Agent** (VM Agent) is used to install, configure, manage and run **Azure Virtual Machine Extensions** (VM Extensions). The VM Agent is a secure, light-weight process that installs, configures, and removes VM extensions on instances of Azure Virtual Machines from the Image Gallery and on custom VM instances if they have the VM Agent installed.
There are two Azure VM Agents, one for Windows VMs and one for Linux VMs. By default, the VM Agent is automatically installed when you create a VM from the Image Gallery, but you can also install the VM agent after the instance is created or install it in a custom VM image that you then upload yourself.
You will now verify that the VM Agent is enabled in the virtual machine created in the previous steps, and after that install the Symantec Protection extension. Finally, you will verify that the extension was correctly installed on the virtual machine. All these steps will be carried out using PowerShell and using some of the same variables set previously.
To verify whether the VM Agent is enabled on the virtual machine, run these commands:
$vm = Get-AzureVM -ServiceName $cloudSvcName
$vm.VM.ProvisionGuestAgent
The output of the first command should not return any errors, and the second command should be True.
Running these commands will also set the $vm.VM variable, which will be used in upcoming steps to add the extension.
Note: If the value of the $vm.VM.ProvisionGuestAgent property is False, connect to the virtual machine and install the VM Agent. You can download it here. Then, set the value of the variable to True with the following snippets.
$vm = Get-AzureVM -serviceName $cloudSvcName -Name $vmname $vm.VM.ProvisionGuestAgent = $TRUE Update-AzureVM -Name $name -VM $vm.VM -ServiceName $cloudSvcName
Now you will install the Symantec endpoint protection extension.
Execute the following command to add the extension:
Set-AzureVMExtension -Publisher Symantec -ExtensionName SymantecEndpointProtection -VM $vm.VM -Version 12.*
Update-AzureVM -ServiceName $cloudSvcName -Name $vmname -VM $vm.VM
Set-AzureVMExtension sets the properties for the extension about to be installed. Update-AzureVM is the cmdlet that installs the extension.
The output of running all the commands up to now should look like this:
Adding a VM Extension output
To verify that the extension was installed on the virtual machine, run the following command:
Get-AzureVMExtension -VM $vm.VM
The output of the command should look like this:
Get-AzureVMExtension output
After you attach a disk to a virtual machine you need to initialize it so it's ready for use. To do so you will need to log in to the machine to finish the initialization of the new data disk attached.
Run the following command to create a remote desktop protocol file (rdp) and launch it. When prompted to log in, use the credentials for the administrator user you configured when creating the virtual machine.
Note: The location for the rdp file provided must exist, otherwise you will see an error.
Get-AzureRemoteDesktopFile -ServiceName $cloudSvcName -Name $vmname -LocalPath 'C:\myvmconnection.rdp' -Launch
This will launch the rdp, effectively starting the flow of connecting to the remote machine.
Get-AzureRemoteDesktopFile output
In the Remote Desktop Connection dialog box, click Connect.
Note:: You might need to wait until the virtual machine has booted for the rdp file to successfully connect and prompt for credentials. If so, retry by opening the rdp file from the location where it was saved until you are prompted for credentials.
Enter the user name and password for the Administrator user that was entered when creating the virtual machine (step 7) and click OK.
Entering the admin user credentials
In the Remote Desktop Connection dialog box, click Yes to verify the identity of the remote computer. You can check "Don't ask me again for connections to this computer" if you do not want to see this dialog box again.
Verifying the virtual machine identity
After a few seconds, the remote desktop window opens and starts setting up the session for the administrator user. Once it is finished, you will see the Server Manager Dashboard open, which you will use in the following steps to configure the data disk that you attached previously.
For all other purposes, you could now work with this machine as you would with any other machine in your own environment.
Using the virtual machine
Now you will configure the data disk that you attached to the Virtual Machine.
In the Server Manager Dashboard that is open in the virtual machine, click File and Storage Services.
Clicking File and Storage Services
Once you are in the Servers pane of File and Storage Services, click Disks.
Viewing the disks in File and Storage Services
The disks available in the machine are listed. You will see one that is listed as Microsoft Virtual Disk, with the partition Unknown and Capacity set to the size entered when the disk was created.
Right-click the disk and select Initialize.
Initializing the disk
Click Yes in the confirmation message box to confirm you want to continue erasing all data on the disk.
Confirming initialization of the disk
After a short wait, the disk now has a Partition set. Right-click the disk and select New Volume.
Clicking New Volume in the context menu
Click Next in the New Volume Wizard dialog box that opens.
In the Server and Disk step of the New Volume Wizard, click Next.
In the Size step of the New Volume Wizard, update the volume size if desired and then click Next.
New Volume Wizard - Size step
In the Drive Letter or Folder step of the New Volume Wizard, update information as desired and click Next.
In the File System Settings step of the New Volume Wizard, update information as necessary and click Next.
New Volume Wizard - File System Settings step
In the Confirmation step of the New Volume Wizard, review the information and click Create.
After the new volume is created, click Close.
You can now open a File Explorer window and confirm the disk is ready to be used.
Viewing attached disk open in File Explorer, ready to be used
##Creating a virtual machine using a Runbook
Azure Automation allows you to automate the creation, deployment, monitoring, and maintenance of resources in your Azure environment using a highly scalable and reliable workflow execution engine.
An Azure Automation account contains:
In this task you will create and start a Runbook from scratch to create a virtual machine. You will also create the necessary assets for this Runbook, and start it. Before that you will ensure that a couple of prerequisites needed for the task are set up.
For the Runbook to be created and run successfully you will need to ensure that the subscription contains a storage account and an organizational account that is co-administrator.
To verify whether you already have a storage account, and create a new one if you don't follow these steps:
Sign in to the Azure Management Portal.
The All Items view will show by default. Find in the table a row with Type = Storage Account. Otherwise, click Storage in the left sidebar to view only Storage Accounts.
Checking whether an storage account exists
If you can find at least one storage account to use, skip the next step. Otherwise, the next step indicates how to create one.
Click NEW in the bottom bar, then select DATA SERVICES > STORAGE > QUICK CREATE and specify a storage name and a location.
Creating a new storage account
Some non-interactive login methods only work with an organizational account. An organizational account is a user that is managed by your organization, and defined in the Azure Active Directory instance for your organization. This is the case of the runbook.
If you do not currently have an organizational account, and are using a Microsoft account to log in to your Azure subscription, you can create one using the following steps.
Note: To be able to create a user account in the default Active Directory for the subscription you need to be a Global Administrator for your subscription. If you are not you will need to either request this permission or request that a Global Admin performs these steps for you.
From the Azure Management Portal, click on Active Directory.
Click the row for the Default Directory to navigate to the Active Directory page, and then click the Users tab.
Clicking the Users tab for the directory
Click ADD USER in the bottom bar.
Clicking Add User in the bottom bar
The Add User wizard will appear and prompt you to enter user information. Keep the Role set to User. During the creation of the user you will be supplied with both an e-mail address for the user and a temporary password. Save this information as it is used in another step.
Organizational account creation
From the management portal, click Settings in the sidebar, and then click the Administrators tab.
Clicking Administrators in Settings
Click Add in the bottom bar, and add the new user as a co-administrator. This allows the work or school account to manage your Azure subscription.
Clicking Add User to Administrators
User was added as co-administrator
Finally, log out of the Azure portal and then log back in using the work or school account. As this is the first time logging in with this account, you will be prompted to change the password.
For more information on signing up for Microsoft Azure with a work or school account, see Sign up for Microsoft Azure as an Organization.
Log out of the Azure portal and then log back in using your own account.
Click NEW in the bottom bar and then select APP SERVICES > AUTOMATION > RUNBOOK > QUICK CREATE.
Creating a new Runbook
Note: You can create new Runbooks using the gallery where you can find samples created by Microsoft and the community.
Runbook Gallery
In the QUICK CREATE section enter a name for the Runbook (e.g.: New-AzureVM), select the Create a new automation account option from the Automation Account selector, and set a valid account name. Finally, click CREATE.
Creating a new Runbook and Automation account
When both the Automation account and the Runbook are ready, click the EDIT RUNBOOK button in the Runbook notification.
Selecting to edit the new Runbook
This will navigate to the workflow edition page, which will show the following outline. You will build the Runbook script in the next steps.
workflow New-AzureVM
{
}
Make sure all the code you copy into the workflow is inside the curly braces that define the workflow, and that there are no lines after that. Also, the workflow name should match the Runbook's name.
In the DRAFT view of the Runbook, add the following code to the workflow definition in order to add parameters. These parameters will later appear in a dialog box when you run the Runbook.
param
(
[Parameter(Mandatory=$true)] [String] $ServiceName,
[Parameter(Mandatory=$true)] [String] $StorageAccountName,
[Parameter(Mandatory=$true)] [PSCredential] $AzureCredential,
[Parameter(Mandatory=$false)] [String] $VMName = "VM-Instance",
[Parameter(Mandatory=$false)] [String] $VMInstanceSize = "ExtraSmall"
)
The parameters defined by the workflow are:
Now, add the following code below the parameters definition to get and configure the Azure Credentials from the Automation Asset list.
# Get the Azure credentials and connect to Azure #######################################################
# Get the credential to use for Authentication to Azure and Azure Subscription Name
$AzureSubscriptionName = Get-AutomationVariable -Name 'Subscription name'
if($AzureSubscriptionName -eq $null)
{
throw "No variable asset was found by name 'Subscription name'. Please create it."
}
# Connect to Azure
$AzureAccount = Add-AzureAccount -Credential $AzureCredential
The Get-AutomationVariable CmdLet retrieves the variable with the name Subscription name. You will create this variable in the Assets tab of the Automation Account for the Runbook later.
Add the following code below the code you just added in order to get the credentials that will be used to access the virtual machine.
# Get the VM credentials ###############################################################################
$VMCred = Get-AutomationPSCredential -Name 'VM credentials'
if($VMCred -eq $null)
{
throw "No Credential asset was found by name 'VM credentials'. Please create it."
}
$VMUserName = $VMCred.UserName
$VMPassword = $VMCred.GetNetworkCredential().Password
The Get-AutomationPSCredential CmdLet retrieves an object of type PSCredential with the name VM Credentials. As with the $AzureCredentials parameter, you will create an Automation Asset named VM credentials, of type "credentials", in an upcoming step.
Next, add the following code after the code added in the previous step. This code defines an InlineScript block that contains some variable definitions, including the image to be used to create the virtual machine.
InlineScript
{
$VMUserName = $using:VMUserName
$VMPassword = $using:VMPassword
$VMName = $using:VMName
$VMInstanceSize = $using:VMInstanceSize
$VMImage = 'a699494373c04fc0bc8f2bb1389d6106__Windows-Server-2012-Datacenter-201412.01-en.us-127GB.vhd'
$AzureAccount = $using:AzureAccount
$AzureSubscriptionName = $using:AzureSubscriptionName
$ServiceName = $using:ServiceName
$StorageAccountName = $using:StorageAccountName
}
Add the following code inside the InlineScript block, right below the variable definitions, to retrieve the Storage account that will be used. This code sets the azure subscription to be used as well as the storage account. Additionally, it validates that the storage account exists.
# Set Azure subscription and storage ################################################################
Set-AzureSubscription -SubscriptionName $AzureSubscriptionName -CurrentStorageAccountName $StorageAccountName
$storageAccount = Get-AzureStorageAccount | Where-Object { ($_.StorageAccountName -eq $StorageAccountName) }
if ($storageAccount -eq $null)
{
throw "Could not retrieve storage account '{0}'. You need to create it first." -f $StorageAccountName
}
$Location = $storageAccount.Location
Finally, add the following code inside the InlineScript block, right below the code added in the previous step. This code will create the virtual machine the same way it was created in the Create virtual machine with PowerShell task.
# Main script ########################################################################################
# Check whether a VM by name $VMName already exists, if it does not exist create VM
Write-Output ("Checking whether VM '{0}' already exists.." -f $VMName)
$AzureVM = Get-AzureVM -ServiceName $ServiceName -Name $VMName
if ($AzureVM -eq $null)
{
Write-Output ("Creating VM with service name {0}, VM name {1}, image name {2}, Location {3}" -f $ServiceName, $VMName, $VMImage, $Location)
# Create VM
$CloudServiceInfo = Get-AzureService | Where-Object { ($_.ServiceName -eq $ServiceName) }
if( $CloudServiceInfo -eq $null)
{
$AzureVMConfig = New-AzureQuickVM -Windows -ServiceName $ServiceName -Name $VMName -ImageName $VMImage -Password $VMPassword -AdminUserName $VMUserName -Location $Location -InstanceSize $VMInstanceSize -WaitForBoot
}
else
{
if ($CloudServiceInfo.Location -eq $Location)
{
$AzureVMConfig = New-AzureQuickVM -Windows -ServiceName $ServiceName -Name $VMName -ImageName $VMImage -Password $VMPassword -AdminUserName $VMUserName -InstanceSize $VMInstanceSize
}
else
{
throw "Cloud service location does not match the storage account location."
}
}
$AzureVM = Get-AzureVM -ServiceName $ServiceName -Name $VMName
if ($AzureVM -ne $null)
{
Write-Output ("VM '{0}' was created successfully" -f $VMName)
}
else
{
throw "Could not retrieve info for VM '{0}'. VM was not created" -f $VMName
}
}
else
{
Write-Output ("VM '{0}' already exists." -f $VMName)
}
Now that the script is complete, publish the Runbook by clicking the PUBLISH button in the bottom bar.
Publishing the Runbook
Click YES in the confirmation prompt that appears after clicking PUBLISH.
Clicking yes to save and publish the Runbook
This publishes the Runbook and leaves it one step closer to execution. Now you will add the Assets that will be consumed by the Runbook, and later you will start the Runbook.
Navigate to the Automation account by clicking the back arrow above the Runbook name.
Navigating to the Automation account
Click the ASSETS tab.
Navigating to the Automation Assets tab
Click the ADD SETTING button to add a new asset.
Adding a new asset
In the ADD SETTING dialog box, select the ADD CREDENTIAL option.
Adding a credential
In the ADD CREDENTIAL dialog box, select Windows PowerShell Credential as Credential Type and type VM credentials as the name. Then click Next.
Creating the virtual machine credential asset
Set the user name and password you want to use for the virtual machine user and click the check button.
Setting the user name and the password for the virtual machine
Repeat the previous steps to add a new credential with the name Azure Credentials. This defines an asset for the credentials that will be used when executing the Runbook. In this case, use the credentials of the organizational account created at the beginning of this task.
Now, create a new variable by clicking the ADD SETTING button one more time. This time click ADD VARIABLE.
Adding a variable
Select String as VARIABLE TYPE, type Subscription name in the Name field, and click Next.
Creating a variable asset for the subscription name
Enter the name of your subscription (i.e.: Free Trial) and click the check button.
Setting the value of the variable with the subscription name
Now that all assets and variables have been created, you will start the Runbook. To do this, navigate to the RUNBOOKS tab, make sure that the Runbook you just created is selected, and click the START button in the bottom bar.
Starting the Runbook
Complete all the values in the START RUNBOOK dialog box and click Next.
Note: Each input in the dialog box matches one of the workflow parameter's and includes a basic type validation. Additionally, the default values are already in place.
- AzureCredential: identifier for the Azure Credential asset created earlier (e.g. Azure Credentials).
- ServiceName: cloud service name in which the virtual machine will be created. Type a new name.
- StorageAccountName: name of the storage account created at the beginning of this task.
- VMInstanceSize: size of the virtual machine. Leave the default value (ExtraSmall).
- VMName: name of the virtual machine to be created. Type the desired name or leave the default value (VM-Instance).
Completing the form in the START RUNBOOK dialog box
This will start running the Runbook.
Click the VIEW JOB button in the notification that is shown.
Clicking the VIEW JOB button
Wait until the job has finished running. This may take a few minutes. You should see a message informing that the vm was created successfully and the status of the job will change to Completed.
Note: You can switch to the HISTORY tab to see more detailed output.
Waiting for the job to complete
Finally, navigate to the Virtual Machines section of the portal and validate that your new VM is ready.
Note: you may have to refresh the page by pressing Ctrl+F5 for the Virtual Machine to show up.
Validating that the virtual machine was created
##Create Virtual Machine using ARM Templates
In this task you will learn how to create a virtual machine using ARM Templates.
###Resources and Architecture Diagram:
The following resources are created by this template:
1 Load balancer with NATing rules.
Architecture diagram for ARM Template
The below Deploy to Azure button embeds an Azure ARM template which creates one or two Windows Server 2012R2 VM(s) with IIS configured using DSC. It also installs one SQL Server 2014 standard edition VM, a VNET with two subnets, NSG, loader balancer, NATing and probing rules.
In order to create virtual machine using ARM, perform the following steps:
Click on the Deploy to Azure button which will navigate you to Azure Portal with Custom Deployment.
Custom Deployment using Azure ARM - using Deploy to Azure button
On the Custom Deployment blade that opens, enter the parameters:
Review the default settings, such as the Subscription(if you have multiple), Resource Group(create or select an existing group), and Resource Group Location and finally Legal Temrs, then Click Create which will add the resource group on to dashboard.
Creating the architecture using ARM Template
In the meanwhile, you can click on Deploying Template deployment which was created on the dashboard.
Azure ARM Template deployment Status
Once the Template Deployment succeeds, you will have WebServer with IIS Installed and SQL Server 2014 Standard deployed on a Virtual Netowrk with 2 subnets with NSG rules and a Load Balancer with NATing rules. Click on the Resource Group Tile pinned on the dashboard and then click on each resource for more details.
Azure ARM Template deployment Succeeds
Now, the 2-tier architecture is created with all necessary resources, to check whether all the rules are applied we will deploy an ASP.NET application and a Sample Database(AdventureWorks2012).
Click on dbNsg which is a Netowork security group and delete the outbound Security rules (Prioirity - 200) - We do this step to download the below AdventureWorks2012 database.
Download RDPs for both Database server and Application server and login with the credentails and download the ASP.NET application content into appserver and AdventureWorks2012 database into Database server.
A sample ASP.NET Application content can be downloaded here : application content
Sample Database can be downloaded here : [AdventureWorks2012] (http://opsgilitytraining.blob.core.windows.net/public/AdventureWorks2012.bak)
Once you download application content onto app server extract the .zip file and copy the content and past in C:\inetpub\wwwroot.
Copy content in wwwroot
Open Database Server, and Open SQL Server Management Studio 2014 login with Windows Authentication for restoring the AdventureWorks2012 database.
Copy the .bak file to the Backup location "C:\Program Files\Microsoft SQL Server\MSSQL12.MSSQLSERVER\MSSQL\Backup" and click OK.
Restoring Backup database file
In object explorer go to Security section and Login subsection Right Click and New Login and create a user with SQL Server authentication and in the default database select as AdventureWorks2012
Create a login user
On Left side you have Server Roles -> Select public and sysadmin and check in User Mapping whether public is selected or not and click OK
So till now we have an application content in appserver and database in Database Server. Fianlly we have to setup the NSG Outbound rule which we have deleted earlier to Database Server through portal.
In Azure Portal Click on the resource group which we just created and in the resources click on dbNsg and click on All Settings and Outbound security rules and click on add and fill the details as below:
Adding a Outbound NSG rule
And Finally login into AppServer and open inetpub\wwwroot and Open Web.Config in notepad and replace the ConnectionString with the below code:
<add name="DefaultConnection"
connectionString="Data Source=tcp:{Destination-Internal-IP},1433;Initial Catalog=AdventureWorks2012;User ID={User-created-DbServer};Password={password};Encrypt=true;Trusted_Connection=false;TrustServerCertificate=true" providerName="System.Data.SqlClient"/>
<add name="AdventureWorksEntities" connectionString="metadata=res://*/Models.AdventureWorks.csdl|res://*/Models.AdventureWorks.ssdl|res://*/Models.AdventureWorks.msl;provider=System.Data.SqlClient;provider connection string="data source=tcp:{Destination-Internal-IP},1433;initial catalog=AdventureWorks2012;Uid={User-created-DbServer};Password={password};multipleactiveresultsets=True;App=EntityFramework"" providerName="System.Data.EntityClient" />
NOTE: Before replacing the connection string, do change the following text with respective values
1) Destination IP address : {Destination-Internal-IP} -> Destination IP 2) User ID: {User-created-DbServer} -> User ID for SQL Authentication 3) Password: {password} -> Password for SQL Authentication
Now you can verify by copying the Loadbalancer IP address onto browser and you will see an asp.net application with data populating from the DB Server.
Output of the application
##Appendix - Cleanup
In this task you will learn how to delete the virtual machines created in the previous sections, along with the related data disks created.
Scroll to the bottom on the left pane and Click Browse >. Then either search in the search box at the top or scroll down and find Virtual machines (Classic).
Clicking Browse in the left Menu
A page listing all Virtual Machines will be displayed.
Viewing all virtual machines created
Click the ... menu to find the virtual machine to delete and in the context menu that opens, click Delete.
Deleting a virtual machine
In the Confirmation blade that opens, type the virtual machine name, select all other items to delete like disks and domain names, and click the Delete button.
Confirming the deletion of the virtual machine
The virtual machine as well as other items selected in the previous step will be deleted. You can monitor the progress of this operation from the Notifications Hub.
Once complete, the Virtual Machines list will refresh and the virtual machine recently deleted will no longer appear. Follow the same instructions to delete all other virtual machines created in this lab.
##Summary
By completing this lab you have learned how to create virtual machines using several different methods: the Azure Portal interface, the Cross-Platform Command Line Tools, PowerShell and Automation Runbook. Additionally, you have seen how to attach an empty datadisk to the virtual machine, how to generate a Remote Desktop Protocol file to connect to the machine, and how to install extensions.


Sea of Calm - Take time to enjoy magic hour on the coast
Sea of Calm - Enjoy magic hour
Hiking - 10 Best Winter Hikes in the Pacific Northwest
Winter Hinking - Best PNW Hikes
Jump for Joy - Celebrate all the things
Jump for Joy - Celebrate the moment
Art Hour - Create and build using color
Art Hour - Create beautiful things


Money Game. Should Red double? If doubled, should White take?
pips Red=142 White=94
(CorrectAnswer= 0/0, ErrorScore= 0)
I dropped this quickly as did everybody else I have showed it to.
However, XG rates this as the skinniest of takes! Once you start to look at the various permutations of how White can win from here the answer becomes a little more credible but it’s still difficult to see White getting to the necessary percentage to make this a take.
But XG has White winning 27% of the time with 12% gammons. One factor is that the cube is very useful to White and he doesn’t always have to escape both rear checkers to win the game.
He can escape one and have one at the edge of Red’s prime and that is enough in some variations. An interesting position I think you will agree.
However, XG rates this as the skinniest of takes! Once you start to look at the various permutations of how White can win from here the answer becomes a little more credible but it’s still difficult to see White getting to the necessary percentage to make this a take.
But XG has White winning 27% of the time with 12% gammons. One factor is that the cube is very useful to White and he doesn’t always have to escape both rear checkers to win the game.
He can escape one and have one at the edge of Red’s prime and that is enough in some variations. An interesting position I think you will agree.
Cube analysis 2-ply cubeless equity +0.443 0.699 0.191 0.010 - 0.301 0.154 0.002 Cubeful equities: 1. Double, take +0.681 2. Double, pass +1.000 (+0.319) 3. No double +0.633 (-0.048) Proper cube action: Double, take


datatools is a rich collection of command line programs targetting data conversion, cleanup and analysis directly from your favorite POSIX shell. It has proven useful for data collaberations where individual members of a project may prefer different toolsets in their analysis (e.g. Julia, R, Python) but want to work from a common baseline. It also has been used intensively for internal reporting from various Caltech Library metadata sources.
The tools fall into three broad categories
See user manual for a complete list of the command line programs. The data transformation tools include support for formats such as Excel XML, csv, tab delimited files, json, yaml and toml.
Compiled versions of the datatools collection are provided for Linux (amd64), Mac OS X (amd64), Windows 10 (amd64) and Raspbian (ARM7). See https://github.com/caltechlibrary/datatools/releases.
Use “-help” option for a full list of options for each utility (e.g. csv2json -help
).
The tooling around transformation includes data conversion. These include tools that work with CSV, tab delimited, JSON, TOML, YAML and Excel XML.
There is also tooling to change data shapes using JSON as the intermediate data format.
Various utilities for simplifying work on the command line.
datatools provides the string command for working with text strings (limited to memory available). This is commonly needed when cleanup data for analysis. The string command was created for when the old Unix standbys- grep, awk, sed, tr are unwieldly or inconvient. string provides operations are common in most language like, trimming, spliting, and transforming letter case. The string command also makes it easy to join JSON string arrays into single a string using a delimiter or split a string into a JSON array based on a delimiter. The form of the command is string [OPTIONS] [ACTION] [ARCTION_PARAMETERS...]
string toupper "one two three"
Would yield “ONE TWO THREE”.
Some of the features included
See string for full details
See INSTALL.md for details for installing pre-compiled versions of the programs.


Tell your non-tech friend a story about a time you:
- Got blocked on a simple problem:
- What was the problem? - I had a spelling error in my code and I thought was writing the code correctly.
- What problem solving techniques did you use? – Wrote the code out again, looked at other examples and checked individual words for errors.
- How did you feel throughout the process? – I felt frustrated that I could not complete the task at hand once I had solve the problem I felt irritated and relieved.
- What did you learn? – That you should watch your spelling when typing code.
- Solved a problem in an elegant way:
- What was the problem? – Having a more compact menu for smaller screens.
- What problem solving techniques did you use? - I knew that I had to use a method that changed could swap out one menu for another based on screen size.
- How did you feel throughout the process? –While I was trying to master the method I was getting annoyed and frustrated but once I got it working I was so happy!
- What did you learn? – That I need to read then experiment as I need to
Reflect on how confident you feel using the problem solving techniques and process:
- Pseudocode – Need to work on this have not had much experience with this.
- Trying something – This is the thing that I experience on a day to day
- Rubber ducky method – Surprisingly I find this works very well. I end up find this combined with a bit of detective work does the tick. I find that sometimes this makes happens when I talks to peers oddly enough.
- Reading error messages – Still a novice I need to have some more coaching on this skill.
- Console.logging –Something I use all the time but sometimes I don’t get the results I want!
- Googling – Do this all the time its second nature to me.
- Asking your peers for help – I do this when googling fails me but I feel that I may be asking too much time away from them.
- Asking coaches for help – I should use this more but I feel again that I feel that I may be asking too much time away from them.
- Improving your process with reflection – This one I am trying to be kinder and more realistic to myself rather than having too unrealistic expectations.
Using the JS Array docs as a starting point, describe what these functions do in your own words:
- .map() -Allows us to look in to a digital container and give an each item an equation then put the answers in a new container.
- .filter() - A way in which we can look in to a digital container and pick items out that meet our defined requirements.
- .reduce() – A way in which we can look in to a digital container and combines them in to one.


--- layout: page title: Pricing ---
Your password must be 8-20 characters long, contain letters and numbers, and must not contain spaces, special characters, or emoji.
50 characters maximum.


Animation
A basic collection of smooth animations to use within your page.
Usage
To apply this component, add any .uk-animation-*
class to an element and it will fade in with a nice animation. These classes are commonly set by using JavaScript to apply the animation to specific behaviors.
| Class | Description |
|---|---|
.uk-animation-fade |
The element fades in. |
.uk-animation-scale-up |
The element scales up. |
.uk-animation-scale-down |
The element scales down. |
.uk-animation-slide-top |
The element slides in from the top. |
.uk-animation-slide-bottom |
The element slides in from the bottom. |
.uk-animation-slide-left |
The element slides in from the left. |
.uk-animation-slide-right |
The element slides in from the right. |
.uk-animation-shake |
The element shakes. |
.uk-animation-scale |
The element scales down without fading in. |
Example
Hover over any of the boxes to see the animation.
Markup

...

Reverse modifier
By default, all aimations are incoming. To reverse any animation, add the .uk-animation-reverse
class.
Example
Hover over any of the boxes to see the animation.
Markup

...

Duration modifier
To stretch the animation duration to 15 seconds, add the .uk-animation-15
class.
Example
Markup

...

Origin modifier
By default, scaling animations originate from the center. To modify this behavior, add one of these classes.
| Class | Description |
|---|---|
.uk-animation-top-left |
The animation spreads from the top left. |
.uk-animation-top-center |
The animation spreads from the top center. |
.uk-animation-top-right |
The animation spreads from the top right. |
.uk-animation-middle-left |
The animation spreads from the middle left. |
.uk-animation-middle-right |
The animation spreads from the middle right. |
.uk-animation-bottom-left |
The animation spreads from the bottom left. |
.uk-animation-bottom-center |
The animation spreads from the bottom center. |
.uk-animation-bottom-right |
The animation spreads from the bottom right. |
Example
Hover over any of the boxes to see the animation.
Animation hover
To trigger an animation on hover, just add the .uk-animation-hover
class to the animated element itself or to a container.
Example
Markup

...

...


{% trans "Announcements" %}
{% for post in posts %}
{{ post.published|date:"M" }} {{ post.published|date:"d" }}
{{ post.published|date:"Y" }}
{{ post.title }}
{% blocktrans with author=post.author.get_full_name %}by
{% endblocktrans %}{% trans "No announcements have been published." %}
{% endfor %}
{# homepage-about for each language #}
{% with lang=LANGUAGE_CODE|default:"en"|slice:":2" %}
{% box "homepage-about-"|add:lang %}
{% endwith %}


Matthew McConaughey Launches Eco-Friendly Cabin With Hopes Of ‘Inspiring Australians To Reconnect With Nature’
by Becca LongmireMatthew McConaughey just launched an eco-friendly cabin, dubbed The Reserve, in Australia.
The actor, who spent a year living in the country as a Rotary exchange student in the 1980s, teamed up with Wild Turkey’s charity initiative, With Thanks, to design the home. The launch was held at Sydney’s Royal Botanic Gardens Wednesday.
Aussie twins Chris and Cam Grant, founders of travel startup Unyoked, which offers private cabins in the wilderness with “minimum footprint and maximum chill,” helped design the hut with McConaughey.
The cabin will be rented out once it is moved to a wilderness area in New South Wales.
McConaughey said in a statement, according to Just Jared: “I’ve always been in awe of Australia’s natural beauty.
“My hope now is that The Reserve by Wild Turkey x Unyoked cabin will inspire Australians to reconnect with nature as an antidote to the frenetic pace of life. I’m also proud that the cabin will form part of the Australian Wild Turkey ‘With Thanks’ initiative that will support people and organizations who demonstrate unwavering conviction to preserving and protecting Australia’s great wilderness and wildlife.”


Murari ThakurJunior Banking Officer | >
INTRODUCTION: |
I am a hardworking individual who has completed 12th std. Commerce and is now pursuing , graduation in B.com. While i am studying my NIIT Certificate in banking and Finance I have two years of Working Expericence as an Office assistant as well as Field Technical Officer for a telecommunication company. |
EDUCATION: |
|
Working Expericences |
|
KNOWLEDGE & SKILLS |
RECENT COURSES |
|
HOBBIES |
|
LANGAGUGE |
|


Which Epicodus course is right for you!
Answer a few questions and find out which course may fit the best with your interests and plans for the future.
You will get the most out of the C#/.NET course.
The C# ("C sharp") programming language is most commonly used with the .NET framework.
Students who are well-versed in C# programming can use it to creat
client applications, database applications, distributed components, and much more.
Students who learn C# programming and combine it with their knowledge of the .NET framework
can target larger enterprises, government agencies, and companies serving enterprise and
government clients for employment.
Companies using C# and .NET who have hired Epicodus graduates include Windsor and Incomm.
You will get the most out of the Ruby/Rails course.
Ruby is a programming language focused on simplicity and productivity.
It has an elegant syntax that is natural to read and easy to write.
The Ruby programming language is most commonly used with the Ruby on Rails framework.
Ruby and Rails are typically used by younger companies and startups, especially for building
interactive web applications. Companies using Ruby and Rails who have hired Epicodus
graduates include New Relic, LivingSocial, and SpendWell.
You will get the most out CSS/Design course.
Web design is a process of conceptualizing, planning, and building a collection of electronic files that determine the layout, colors, text styles, structure, graphics, images, and use of interactive features that deliver pages to your site visitors. Web Design is a crucial component in web development, and students who learn design will be able to engineer positive and interactive user experiences through innovative interfaces.


You need to check out this Apple AirPods deal
by Joseph GreenTL;DR: The Apple AirPods and charging case bundle is on sale for £129 on Amazon, saving you 19% on list price.
Genuinely good deals on Apple products are few and far between, so we feel the need to shout when we come across something significant.
You can now pick up Apple AirPods for just £129 on Amazon, with a charging case. This bundle is normally listed at £159, meaning you save £30 with this deal. That's worth a loud shout.
Just in case you've been living under a rock for the last few years, Apple AirPods are just about as stylish as it gets. The clever little earbuds combine intelligent design with breakthrough technology to produce crystal clear sound. They also now feature hands-free access to Siri using just your voice, and offer up to three hours of talk time on a single charge.
There is no time limit on this deal, but we can't see it sticking around for too long. If this deal interests you, we recommend acting fast to avoid disappointment.
Apple AirPods and Charging Case — £129 (list price £159) See Details


So instead of
RenderPartial(“MyPartial”, item)
you better write
RenderPartial(“MuPartial”, new ViewDataDictionary { Model = item })
Just a quick note. Thanks to this forum post.
--- layout: post title: ASP.NET MVC RenderPartial with null Model date: 2009-05-06 12:02:00.000000000 +10:00 comments: true categories: - tricks - development - asp.net mvc ---
RenderPartial(“MyPartial”, item)
RenderPartial(“MuPartial”, new ViewDataDictionary { Model = item })
since the ViewDataDictionary also contains the ModelState which will tell you if fields are invalid etc, it is better to contruct the ViewDataDictionary passing the current ViewData in; therefore your second argument would be as follows:
new ViewDataDictionary(ViewData) { Model = item }


Judges 18:8
And they came unto their brethren to Zorah and Eshtaol: and their brethren said unto them, What say ye?


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import uk.gov.hmrc.gatekeeper.controllers._ @import uk.gov.hmrc.gatekeeper.models._ @import uk.gov.hmrc.gatekeeper.config.AppConfig @import uk.gov.hmrc.apiplatform.modules.gkauth.domain.models.LoggedInUser @import uk.gov.hmrc.gatekeeper.controllers.routes @import uk.gov.hmrc.gatekeeper.views.models.Crumb @this(main: MainView, applicationConfig: AppConfig) @(developer: Developer)(implicit request: Request[_], loggedInUser: LoggedInUser, messagesProvider: MessagesProvider) @main( title = s"${applicationConfig.title} - Delete Developer", breadcrumbs = Seq( Crumb( "Developers", s"${routes.DevelopersController.blankDevelopersPage()}", Some("data-breadcrumb-view-developers") ) ) ) { @defining(developer.applications.filter(_.isSoleAdmin(developer.user.email))) { applications => @if(applications.isEmpty) {
@developer.user.email.text is the only administrator for one or more applications.
Applications cannot exist without an administrator.
Delete the following applications or ask the administrator to appoint a new administrator for them:
@for(application <- applications) { } Finish } } }


In my previous post Composable Repositories, I introduced using extension methods as the repository in applications. This allows repositories to get much better reuse and be more expressive in their usage. In this post I will look at two issues with extension method based repositories in LINQ and introduce some libraries I built to resolve these issues.
First a refresher, in my previous post I used the following query as an example.
public static IQueryable<Person> InRegion(this IQueryable<Person> people, string region)
{
return people.Where(p => p.Addresses.Any(a => a.Region == region));
}
public static IOrderedQueryable<Person> OrderByName(this IQueryable<Person> people)
{
return people.OrderBy(x => x.Name);
}
public static IQueryable<T> Page<T>(this IOrderedQueryable<T> entities, int page, int pageSize = 3)
{
int skip = Math.Max(0, page - 1) * pageSize;
return entities.Skip(skip).Take(pageSize);
}
public static IQueryable<PersonModel> ToViewModels(this IQueryable<Person> people)
{
return people.Select(person => new PersonModel
{
Name = person.Name,
Addresses = person.Addresses.Select(a => a.PostalAddress)
});
}
//and the query
Context.People
.InRegion("Shire")
.OrderByName()
.Page(1)
.ToViewModels()
.ToArray();
As you can see this uses chained extension methods to generate the underlying query.
Issue one: Queryable extensions in the projection
This brings us to the first issue, if you look at the ToViewModels
projection call you will see the following:
Addresses = person.Addresses.Select(a => a.PostalAddress)
Now wouldn’t it be better if we could nest our extension methods here and reuse another projection which relates to addresses? Something like the following:
Addresses = person.Addresses.ToAddressViewModels()
Now if you write this and execute it with Entity Framework you will get the following error:
LINQ to Entities does not recognize the method ‘ToAddressViewModels(Address)’ method, and this method cannot be translated into a store expression.
This is a bit weird as we seem to be able to use extension methods elsewhere in our queries without issue, why is this instance different? Why can we use Select
but not our extension which just does a select internally, The problem here comes down to where this occurs in our expression. As you can see in our extension this is not acting on the root queryable directly but instead effecting what essentially amounts to a sub query.
When we were acting directly on the queryable the LINQ method was essentially visiting the expression returned by our extension methods, however when we use an extension inside the results nothing has been returned yet so the expression visitor needs to evaluate and translate that method to an expression. The issue is that the visitor at that point doesn’t know that the extension you wrote is just another expression (or even that it could possibly be an expression).
Issue two: Single element projection
Imagine our projection was instead into a singular, for example
Address = person.Address.ToViewModel()
This is a very similar problem to that which we are looking at above with one key distinction, we are no longer acting with set based (queryable) logic, instead we are acting on a singular element. At its heart is the same problem as above but it is a little harder to get around.
It would be desirable to solve both of these problems to allow even more expressive queries, especially in relation to projection of entities.
The solution
To be able to solve these problems we need to get into the depths of LINQ and translate our extension methods for the benefit of the downstream expression visitors. This is possible by writing a new expression visitor which replaces the extension method calls in the expression tree with the actual expressions we wanted to execute. This will let our Entity Framework (or generic LINQ based ORM) expression visitor carry on with its translation to SQL without needing to understand the internals of our extension method.
Plugging into the pipeline
The first thing we will need to do is to get our own expression visitor into the mix, we can do this can build a our own queryable implementation, and a queryable extension to convert to our new queryable implementation. This will let us get amongst with our own expression visitor which is executed as we walk the expression tree.
This means we can do something like this to let our expression visitor participate in translating the LINQ query.
Context.People
.AsExpandable()
.InRegion("Shire")
.OrderByName()
.Page(1)
.ToViewModels()
.ToArray();
We are interested especially in the VisitMethodCall
part of the visitor which will get executed for every extension method. At this point we could intercept and do something with every extension method that gets executed in LINQ but this would mean we would need to manually exclude things which Entity Framework understands (like Select
and Where
) and also potentially run into the same problem with things which aren’t actually translatable to SQL, so instead we are going to use a marker attribute to tag extension methods we are OK with replacing, ExpandQueryableAttribute
. Inside the visitor we will then replace any of these queryable replacements with the invoked/expressionised version of the queryable.
This can be used as follows:
[ExpandQueryable]
public static IQueryable<AddressModel> ToViewModels(this IQueryable<Address> addresses)
{
return addresses.Select(address => new AddressModel
{
StreetNumber = address.Number,
Street = address.Line1
});
}
Voila problem one solved.
The next part will be a little more ninja, to replace the non-queryable parts we don’t have anything to invoke and return us an expression. So we are going to need to change the way we write our extension methods to be a little more expression-like. Lets write our singular projection as an expression:
public static Expression<Func<Addresss, AddressModel>> ToViewModelExpression()
{
return address => new AddressModel
{
StreetNumber = address.Number,
Street = address.Line1
};
}
This isn’t really usable in our expression tree yet as we don’t have an entry point from our query. Getting an entry point is a little tricky as how do we can’t just use an expression on a singular without invoking it (which would get us right back to the original problem. So we are going to use a little bit of a trick, let’s create an extension method and use it as a placeholder for the actual expression. We will decorate this with an attribute which points back to the actual expression to execute in its place. When we visit such an extension method in our visitor we will replace it with the expression from the attribute in the expression tree.
[ReplaceInExpressionTree(MethodName = nameof(ToViewModelExpression))]
public static AddressModel ToViewModel(this Address entity)
{
// We could throw a not implemented exception here as we won't ever
// execute this unless we use it outside of our visitor. But doing this
// allows you to use the extension on an in memory object tree without
// needing our custom visitor to replace it.
return ToViewModelExpression().Compile()(entity);
}
This means we can now use our singular extension methods inside our projections, and both of our original problems are solved.
To save you having to write all of this complex expression magic in you application I have put this library on Nuget and Github
Install-Package StaticVoid.Core.IO
A big thanks to those who helped me learn how expression trees work on StackOverflow in the following questions:
- Expression visitor only calling VisitParameter for some lambda expressions
- Projection of single entities in EF with extension methods
And to @LordTerabyte whose code I used as a starting point for these extensions.
Magic but whats the point?
By enabling nesting in our extension methods we can nest our projections so that we can take our data model and transform it into a more appropriate usage model for use in our applications. We can then reuse these translation extensions so if we want something in the a usage model we always use the same code.
But probably more importantly this allows us to solve an under/over fetch problem. All of the projection code is essentially executed inside of SQL, this means that the full data model is available so we don’t need to worry about including the joined tables we require to ensure those navigation properties are not null. We also don’t need to worry about including too much information in the result set as we are only going to get the columns which directly map to our projected model. This is a really big benefit in terms of both code complexity and potential performance bottlenecks.
A final word of caution
This method allows you to push far more logic into SQL for processing. Be very careful to keep in mind the queries you are generating with nested projection and be sure that the SQL you are generating is kept performant. If you aren’t careful about what you write (as with any LINQ based query) you can execute things which are a little crazy when transpiled to SQL.


BARB WIRE **1/2 of **** grade is C+
Barb Wire was written off on everyone's list before it came out. Even mine. To be honest, I saw the film expecting cheesy laughs and extended looks at Pamela Anderson's chest. I was not disappointed on either of the counts.
Barb Wire is a fun rip off/update/spoof of Casablanca (!) and it stars Pamela Anderson as Barb. In the opening scene she twists and turns drinched in water - clothes (what there are of them) clinging to her body. I imagined all the teenage boys gasping, and nodding (this will be a cool movie). Then it follows the plot form of Casablanca, with modern updates and camp thrown in. If you are farmiliar with the '42 classic you will enjoy this film more than the regular viewer.
 This film is trash, and I mean that as a compliment. You may think of Pauline Kael, who observed: "The movies are so rarely great art, that if we can't appreciate great trash, there is little reason to go." Definatly little reason to go to a rip off/update/spoof of Casablanca staring Pamela Anderson and Pamela Anderson's cleavage. You don't go to this film too make an artistic discovery.
I would love to recomend this movie but the ending is unfun and very slow compaired to the high energy start. I have a place in my heart for films like this. Something needs to be said of a film that tries to overcome it's disadvantages with style and heart. This comes close to making it, and I do recomend the film to those who think it may be your cup of tea.
For you who will want to see it, you will want to know the info about the REAL reason to see this film. I'll help you: This film has a suprisingly small amount of nudity provided the fact Lee is the main star. We get many looks at her body in SKIN TIGHT, cleavage revealing outfits and there is a scene of her fully nude, except for soap bubbles. There are also at least two scenes of her breasts. If that sounds like it will work for you ... rent it, but keep it hid from your parents.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


firstName is required.
lastName is required.
Email address is required.
Email address is invalid.
Username is required.
Password is required.
{{passwordError}}


Gareth Wright
Presents
BLOG
My Dev Academy journey
Home
Blogs
About
Cultural Blogs
sprint 1
sprint 2
sprint 3
sprint 4
sprint 4
Technical Blogs
sprint 1
sprint 2
sprint 3
sprint 4


Raman orientation Supplementary Fig. laser mapping polarized SAROM sample scattering (Supplementary channels polarization microscopy no. analysis beam different off-axis cat. data \documentclass[pt]{minimal} \setlength{\oddsidemargin}{-pt} \usepackage{amsbsy} \usepackage{amsfonts} \usepackage{amsmath} \usepackage{amssymb} \usepackage{mathrsfs} \usepackage{upgreek} \usepackage{wasysym} beams D-SAROM measurements orientations polycrystalline used {border-style Phys. shown surface order px;} using #ffffff;} crystal on-axis EBSD map measurement microscope obtained optical size CCD grain performed (Fig. Mater. Note determination focal materials spectra Appl. LINK Polarized angle crystallographic sapphire setup single spectroscopic tablet tensor Figs. PRM high imaging lens mode multiple number objective plane quantitative registration z$$\end{document} (), Movie Optics, Sci. X-ray ^\circ$$\end{document} ambiguity channels. consists experimental light resolution rotation spectrograph step tensors CBZD Chem. Data Euler University crystals design developed effects error information intensity local maps point px; study symmetry time wafer {font-family (Edmund (see Rev. Spectrosc. \begin{document}$$\psi analyzer angles axis based carbamazepine ceramics confocal differently exposure focused focusing font-size incident like limited material possible provide results scanning signal simultaneous state theoretical However, Orientation Table [], \begin{document}$$z(\psi _i^ _{_i}^\,\psi _{_s}^)\tilde case channel characterization collected color components diffraction double; electron grains method provides spatial spectral studies < (). (Semrock, (Thorlabs, National Nature Soc. Technical Therefore, Three-dimensional Tsuboi Wollaston applied area background biological border-color border-width capable combination correction depth designed detector development dichroic excitation filter fitting grid.. illumination lasers mirror misorientation particles path pharmaceutical present provided raman range solid; source stress technique total use versus wafers wavelength {font-style {font-weight µm –). ./. ./S-()- Adv. Commons Creative Here, Ilchenko NIR Oleksii Rep. Spectrograph _s^{{\mathrm{off}} acquisition ambiguities backscattering beamsplitter bold code collagen collection compared complex concept configurations corresponding courier; delivery demonstrated dimension diode distribution em; experimentally extended http://orcid.org/--- images including inorganic investigation low organic pole power presented propagation pt;} related required respect responses resulting scattered simultaneously slit spectroscopy spectrum spherical spot structure type used. visible nm µm,


This text is hidden starting from xs viewport size.
This text is hidden starting from sm viewport size.
This text is hidden starting from md viewport size.
This text is hidden starting from lg viewport size.
This text is hidden starting from xl viewport size.
This text is hidden starting from xxl viewport size.
This text is visible starting from xs viewport size.
This text is visible starting from sm viewport size.
This text is visible starting from md viewport size.
This text is visible starting from lg viewport size.
This text is visible starting from xl viewport size.
This text is visible starting from xxl viewport size.


Triskel:
I am Triskel. Remember that! If you want to become an Assassin, you will have to meet me again someday.
Quest


{% if success %} User id {{username}} created for email address {{emailAddress}}. {{emailSuccessMessage}} {% else %} Creation failed for {{ username }} with email address {{emailAddress}} because {{ message }} {% endif %}


Using hugo to create a website is very easy, as shown in these steps
I followed the hugo quick start guide
And the introduction theme’s instructions
Because arch linux has a wide breadth of supported programs in it’s repos, I was able to simply run:
sudo pacman -S hugo
And use the hugo new site website
command to create the website in a folder named website/
Using hugo’s theme browser, I found a theme called introduction that really felt correct for this website.
Then, I added that theme as a submodule using
cd themes
git submodule add https://github.com/vickylai/hugo-theme-introduction.git introduction
To complete the integration of the theme, I Followed the instructions on the theme’s site
To add some content for the website, I
Using this easy to follow guide, I was able to easily set up a system where I can develop the website seperately from the deployed repo in my github account. I chose to host the website this way because now I am able to keep the version control history clean, with the recompilations of the website separate from the development.
creikey.github.io
website
website
reporm -rf public/
creikey.github.io
website as a submodule using git submodule add -b master git@github.com:creikey/creikey.github.io.git public
Setting up a website with hugo is very easy, and even fun!
Thanks for taking time out of your day to read this blog. I hope that you found some sort of usefulness from my writing


--- layout: barebones no_footer: true wide_layout: true title: file arshive description: Select source and file ios_app_name: photo --- Forwards, to sorce code and files!


His feast day is not until September, so there is no reason why I should be mentioning St Joseph of Cupertino today, other than mere whim. You can read about him here, to which I would add these observations from Some Human Oddities : Studies In The Queer, The Uncanny And The Fanatical by Eric John Dingwall (1947):
“At the age of eight it was reported that he had his first ecstasy : and his behaviour at school, where occasionally he used to sit agape and motionless and with his eyes raised to heaven, earned him the nickname of ‘Open Mouth’… he was admitted to the Capuchin Order in August 1620. At first he was destined to work in the refectory, but the result of his frequent fits of absence of mind and ecstatic states on the crockery was disastrous, and Joseph added to the irritation caused by his breakages by wearing the pieces round his neck… the accounts of his childhood, lack of education and later mental development suggest that he was not far from what today we should call a state of feeble-mindedness. Bishop Bonaventura Claver said that he was idiota.”


You will find this post in your _posts
directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve
, which launches a web server and auto-regenerates your site when a file is updated.
To add new posts, simply add a file in the _posts
directory that follows the convention YYYY-MM-DD-name-of-post.ext
and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works. If you already have a website built with Jekyll, simply copy over your posts.
To change site settings, edit the _config.yml
file found in the root of your repository. Anything under ‘Site Settings’ can be tweaked to your liking.
If you are hosting your site on GitHub Pages, then committing a change to the _config.yml
file will force a rebuild of your site with Jekyll. Any changes made should be viewable soon after. If you are hosting your site locally, then you must run jekyll serve
again for the changes to take place.
In the _config.yml
file, you’ll be able to change the title of your site along with any tagline you want, which shows up in the site header, as well as the description of your site for SEO purposes. You can also change the social media information, and add your own social media icons.
Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll Talk.
Written on November 11th, 2015 by Omar Asensio


Seismometer, other key devices at Jayakwadi dam go ‘out of order’
Retired MERI staff to be enlisted to repair equipment
by PTIThe seismometer, which helps measure the magnitude of an earthquake, and several other key instruments installed at the Jayakwadi dam in Aurangabad district have stopped functioning properly, an official said on Sunday.
Retired staff of the Maharashtra Engineering Research Institute (MERI), who have expertise in repairing these devices, are being roped in to get them fixed.
“The seismometer was installed at the Jayakwadi dam after the devastating earthquake in Killari in Latur district in 1993. This instrument is powerful as it has a range of 10,000 km. In the past, it has recorded the epicentres of earthquakes in Pakistan, Afghanistan, Russia and Nepal,” executive engineer Rajendra Kale said.
“But this and other instruments, like the piezometer, earth pressure cell and slope meter, have been out order for the last two years. Every instrument is important and we are trying to get them repaired soon or get new ones as early as possible,” he said. “We hope to get [the seismometer] repaired within a week. If the repair work does not yield positive results then we will seek permission to purchase a new one,” Mr. Kale said.


A paragraph with class="example" in div.
Click the button to change the text of the first element with class="example" in div.


Rock music is a broad genre of popular music that originated as "rock and roll" in the United States in the early 1950s, and developed into a range of different styles in the 1960s and later. It has gone through an amazing evolution to end up where it is now.
Take a journey into the rock history through the decades and learn about how it has evolved in the last 60 years!
Rock and roll dominated popular music in the 1950s and quickly spread to much of the rest of the world. Its immediate origins lay in a mixing together of various musical genres of the time. In 1951, disc jockey Alan Freed began playing rhythm and blues music for a multi-racial audience, and is credited with first using the phrase "rock and roll" to describe the music.
Elvis Presley was the most successful artist of the popular sound of rock and roll. He brought rock and roll widely into the mainstream of popular culture, popularized the four-man group and also brought the guitar to become the lead instrument in rock music. Presley popularized rockabilly, a genre that combined country with rhythm and blues which some claimed it was a new sound.
In the early-1960s, rock and roll in its purest form was gradually overtaken by pop rock, beat, psychedelic rock, blues rock, and folk rock, which had grown in popularity. British rock broke through to mainstream popularity in the United States in January 1964 with the success of the Beatles. "I Want to Hold Your Hand" was the band's first No. 1 hit on the Billboard Hot 100 chart, starting the British Invasion of the American music charts.
The British Invasion helped internationalize the production of rock and roll, and played a major part in the rise of a distinct genre of rock music, and cemented the primacy of the rock group, based on guitars and drums and producing their own material as singer-songwriters.
The 1970s saw the emergence of hard rock as one of the most prominent subgenres of rock music. It is typified by a heavy use of aggressive vocals, distorted electric guitars, bass guitar, drums, and often accompanied with keyboards.
Acts such as Deep Purple, Led Zeppelin, Queen, Nazareth, and Black Sabbath were highly popular during the first half of the decade. By the second half of the decade, many other acts had also achieved stardom, namely, AC/DC, Kiss, Aerosmith, Van Halen and Ted Nugent.
In the 1980s, rock music was more precisely defined and split up into multiple subgenres. Rock music continued to enjoy a wide audience. Soft rock, glam metal, thrash metal, shred guitar characterized by heavy distortion, pinch harmonics and whammy bar abuse became very popular.
The 1980s saw the emergence of wildly popular hard rock band Guns N' Roses and the successful comebacks of Aerosmith and Alice Cooper in the late 1980s.
The rise of grunge, a hybrid of punk and the hard-rock sound of 1970s and 1980s heavy metal, was popularized in the early 1990s by Seattle-based bands such as Nirvana and Pearl Jam. Grunge’s raw, jarring sound was matched with lyrics that usually seemed to express a downbeat, even nihilistic worldview that was drenched in self-deprecating irony; “I feel stupid and contagious / here we are now, entertain us,” Nirvana singer Kurt Cobain sang in “Smells Like Teen Spirit,” a hit single whose name sprang from a deodorant marketed to teenagers.
Grunge devotees rebelled against the idea of rock stars as glamorous, fashionably coiffed celebrities, instead dressing in flannel shirts and ragged jeans and sporting unruly long hair.
Rock music was still popular, notably alternative rock, and especially genres such as post-grunge, nu metal, pop punk, emo, post-hardcore, metalcore, and in some cases indie rock. During the early 2000s, a new wave of metal began with interest in the newly emerging genre nu metal and genres of a similar style such as rap metal and the later mainstream success rap rock.
Linkin Park's debut album Hybrid Theory, released in 2000, sold over 24 million copies worldwide. In 2004, nu metal lost popularity. Since then, many bands have changed to other genres of music, such as post-grunge, heavy metal, and alternative rock.
Rock has remained popular, although it has declined in chart presence since the late 2000s alongside changes in radio format. These changes were driven by the decline in compact discs and rise of downloads in the music industry, which prompted a focus on top 40 music. Rock has also moved from hard rock and heavy metal, which have dominated since the mid-1980s. Mainstream rock since the early 2010s has become softer and more refined because of indie rock.
Indie rock has become one of the most successful subgenres of the decade. The top widespread indie musicians this decade have been Imagine Dragons, Neon Trees, X Ambassadors, Twenty One Pilots, and many others.