Task

back to top

Read the DTGOV Case Study before you attempt this assignment 

A chief strategic objective of the standardisation of DTGOV’s service portfolio is to achieve increased levels of cost-effectiveness and operational optimisation.

DTGOV is considering the following strategic proposal:

• They plan to retain one (1) of their three (3) data centres solely for data storage. This would entail updating their Active Directory and data storage infrastructure, and moving all other infrastructure into the Cloud.  
• They plan to initially move all their Web Services into the Cloud in order to provide an increased level of HA (High Availability) as well as a better degree of flexibility in supplying data to their customers and employees. This would entail changing their current web software architecture to take advantage of the flexibility and scalability that can be gained by moving to a Microservices model (this would entail the use of such services as AWS Lambda or Azure Functions, Containers, Data Services, and Cloud Edge capability and monitoring).
• They also plan to migrate their LoB (Line of Business) applications to Public Cloud infrastructure to increase their flexibility and availability.  

The DTGOV Board is contemplating this strategy as a way to increase the company’s flexibility and responsiveness. The Board also expects to achieve significant savings on the cost of maintaining their ICT infrastructure by eventually closing the other two (2) existing data centres. They appreciate that this would entail retraining for their existing ICT staff so that they can manage the new Cloud based infrastructure.

DTGOV has again approached you to advise them on this strategy. You have previously advised DTGOV that this strategic approach will mean that they will need to ultimately design and operate a “Hybrid Cloud” methodology, where part of their data centre is “on premise” and another part in a Cloud.

DTGOV also plan to run a Risk and Security Workshop to assess the risks, security issues and possible methods of control that will be required with this “Hybrid Cloud” approach. You will be required to organise, run and facilitate this workshop.

The Board is also concerned about how this strategy will affect their BCP (Business Continuity Plan) and their backup and disaster recovery strategies.

Tasks
Your team has been engaged to provide a report for DTGOV in their planned move to a Hybrid Cloud strategy. 

Team Setup
This assignment is a team assignment. The rationale for using a team approach is that most IT risk management assessments are normally done by teams of between 2-5 Architects, Information Security experts, Operations and Business leaders for each problem. You will be assigned to a team and the team, as a whole, will be responsible for the development of the risk assessment.

Team Member Responsibilities
Each team member will be assessed on:

• The final risk assessment presented by the team;
• The individual contributions that they have made to the risk assessment. This will be shown by the entries that they have made in the Team forum;
• Team members should note that:
  • A total of 20% of the total marks for this assignment are for individual contributions to the team task;
  • A team member without any individual contributions in the Team Forum will be regarded as having not contributed to the risk assessment. This will result in either reduced marks or no marks being awarded to that team member for this assignment.

The tasks:
The team’s task is to prepare a report for DTGOV that discusses the following:

1. Describe which Cloud architectures you would employ to assist DTGOV to meet the Board’s strategy?
   1. Describe each of the architectures that you would use, along with your reasons for deploying it. (10 marks)
   2. Describe the benefits and issues that would be the result of your deployment of these architectures. (10 marks)
2. Describe the risks that you see associated with this new Hybrid Cloud and Microservices strategy. You should name and describe each risk that you identify, and then describe a possible control for the risk. This should be presented in a tabular form. (20 marks)
3. Describe the general Information Security steps and controls that you would recommend to the Board to secure the Hybrid Cloud. You will need to explain to the Board your reasons for recommending these particular security steps. (20 marks)
4. Discuss briefly what you would recommend should be included in DTGOV’s BCP as a result of their adoption of a Hybrid Cloud and Microservices approach. You will need to consider, as a minimum, the issues of application resilience, backup and disaster recovery in a Hybrid Cloud environment. This section should be no more than 2 pages. (10 marks)
5. Discuss the requirements that DTGOV will need to consider in order to conduct remote server administration, resource management and SLA management for its proposed IaaS and PaaS instances (it may be useful to consider Morad and Dalbhanjan’s operational checklists for this section). This section should be no more than two to three pages in length. (10 marks)

The team is to provide a written report with the following headings:

• Proposed Architectures for a Hybrid Cloud
• Risk report for Hybrid Cloud and Microservices
• Proposed Information Security controls
• BCP Changes
• Hybrid Cloud Administration and SLA Management

As a rough guide, the report should not be longer than about 6,000 words. The report is to be loaded into the Team Resource area in Interact.

All risk assessment discussions in the team forum should be exported into a single document and loaded into the Team Resource area in Interact.

It is suggested that the report should be written using Google Docs using MS Word format. Google Docs allows multiple authors to contribute to a single document, and their individual contributions can be more easily assessed.
 

Your team report MUST be presented in MS Word format. Your report should:

• Use Calibri, or a similar font, in 11 or 12 point type.
• All diagrams and images are to be embedded in the document. Diagrams and images that are suppliued separately will not be marked.
• All text should be left-justified.
• Each page must have a header or footer with your name and student number. Page numbers must be shown in the footer of each page, except on the title page.

Select one of the following industries: banking, logistics, oil and gas, or manufacturing.

Using Microsoft® Word, PowerPoint®, or various digital timeline sites, such as ReadWriteThink, Timeline JS, timetoast, etc., create a timeline of low-end and high-end disruptive digital transformations over the past 20 years. The timeline should focus on at least 10 major transformations in your chosen industry and identify how the new direction provided competitive advantages for the companies that used these emerging technologies.

Pick a technologically deficient company within your chosen industry, and write a 1- to 2-page summary of what you would do to develop a digital transformation plan to help your chosen company become technologically up-to-date.

Compare and contrast two difference cloud computing services (Amazon Web Service and Microsoft Azure). Explain the differences and the similarities and select your choice of providers if you had to make the decision for your business. Write up a comparison on the services offered (2 pages maximum). Once again, it is essential that you use your own words (do not just copy and paste from the Internet).

These two links may offer some additional information for this assignment but you are encouraged to use additional sources for your project/assignment.

https://aws.amazon.com/security/introduction-to-cloud-security/

https://azure.microsoft.com/en-us/

Upload your completed assignment here by clicking the BLUE assignment link above.

Need 300 words write up within minimum 2 in text citations in APA format. No plagiarism 

Process Synchronization: Producer-Consumer Problem

The purpose of this programming project is to explore process synchronization. This will be accomplished by writing a program on the Producer / Consumer problem described below. Your simulation will be implemented using Pthreads. This assignment is a modification to the programming project “The Producer – Consumer Problem” found at the end of Chapter 7 of our textbook. 1. Your program must be written using C or C++ and you are required to use the Pthread with mutex and semaphore libraries.

In chapter 3, we discussed how a “bounded buffer” could be used to enable producer and consumer processes to share memory. We described a technique using a circular buffer that can hold BUFFER_SIZE-1 items. By using a shared memory location count, the buffer can hold all BUFFER_SIZE items. This count is initialized to 0 and is incremented every time an item is placed into the buffer and decremented every time an item is removed from the buffer. The count data item can also be implemented as a counting semaphore.

The producer can place items into the buffer only if the buffer has a free memory location to store the item. The producer cannot add items to a full buffer. The consumer can remove items from the buffer if the buffer is not empty. The consumer must wait to consume items if the buffer is empty.

The “items” stored in this buffer will be integers. Your producer process will have to insert random numbers into the buffer. The consumer process will consume a number.

Assignment Specifications

The buffer used between producer and consumer processes will consist of a fixed-size array of type buffer_item. The queue of buffer_item objects will be manipulated using a circular array. The buffer will be manipulated with two functions, buffer_insert_item() and buffer_remove_item(), which are called by the producer and consumer threads, respectively. A skeleton outlining these functions can be found in buffer.h (provided below).

Skeleton outlining (Buffer.h)

#ifndef _BUFFER_H_DEFINED_

#define _BUFFER_H_DEFINED_

typedef int buffer_item;

#define BUFFER_SIZE 5

bool buffer_insert_item( buffer_item item );

bool buffer_remove_item( buffer_item *item );

#endif // _BUFFER_H_DEFINED_

The buffer_insert_item() and buffer_remove_item() functions will synchronize the producer and consumer using the algorithms. The buffer will also require an initialization function (not

supplied in buffer.h) that initializes the mutual exclusion object “mutex” along with the “empty” and “full” semaphores.

The producer thread will alternate between sleeping for a random period of time and generating and inserting (trying to) an integer into the buffer. Random numbers will be generated using the rand_r() function. See the text on page 290 for an overview of the producer algorithm.

The consumer thread will alternate between sleeping for a random period of time (thread safe of course) and (trying to) removing a number out of the buffer. See the text on page 290 for an overview of the consumer algorithm.

The main function will initialize the buffer and create the separate producer and consumer threads. Once it has created the producer and consumer threads, the main() function will sleep

for duration of the simulation. Upon awakening, the main thread will signal other threads to quit by setting a simulation flag which is a global variable. The main thread will join with the other threads and then display the simulation statistics. The main() function will be passed two parameters on the command line:

• The length of time the main thread is to sleep before terminating (simulation length in seconds)

• The maximum length of time the producer and consumer threads will sleep prior to producing or consuming a buffer_item

A skeleton for the main function appears as:

#include <buffer.h>

int main( int argc, char *argv[] ){ Get command line arguments Initialize buffer

Create producer thread(s) Create consumer thread(s) Sleep

Join Threads

Display Statistics

Exit

}

Creating Pthreads using the Pthreads API is discussed in Chapter 4 and in Assignment-1. Please refer to those references for specific instructions regarding creation of the producer and

consumer Pthreads.

The following code sample illustrates how mutex locks available in the Pthread API can be used to protect a critical section:

#include <pthread.h>

pthread_mutex_t mutex;

/* create the mutex lock */

pthread_mutex_init( &mutex, NULL );

/* aquire the mutex lock */

pthread_mutex_lock( &mutex );

/*** CRITICAL SECTION ***/

/* release the mutex lock */

pthread_mutex_unlock( &mutex );

Pthreads uses the pthread_mutex_t data type for mutex locks. A mutex is created with the pthread_mutex_init() function, with the first parameter being a pointer to the mutex. By passing NULL as a second parameter, we initialize the mutex to its default attributes. The mutex is acquired and released with the pthread_mutex_lock() and pthread_mutex_unlock() functions. If the mutex lock is unavailable when pthread_mutex_lock() is invoked, the calling thread is blocked until the owner invokes pthread_mutex_unlock(). All mutex functions return a value of

0 with correct operation; if an error occurs, these functions return a nonzero error code.

Pthreads provides two types of semaphores: named and unnamed. For this project, we will use unnamed semaphores. The code below illustrates how a semaphore is created:

#include <semaphore.h>

sem_t sem;

/* create the semaphore and initialize it to 5 */

sem_init( &sem, 0, 5 );

The sem_init() function creates and initializes a semaphore. This function is passed three parameters: A pointer to the semaphore, a flag indicating the level of sharing, and the semaphore’s initial value. In this example, by passing the flag 0, we are indicating that this semaphore can only be shared by threads belonging to the same process that created the semaphore. A nonzero value would allow other processes to access the semaphore as well. In this example, we initialize the semaphore to the value 5.

In Chapter-6 (Section 6.6), we described the classical wait() and signal() semaphore operations. Pthread names the wait() and signal() operations sem_wait() and sem_post(), respectively. The code example below creates a binary semaphore mutex with an initial value 1 and illustrates it use in protecting a critical section:

#include <semaphore.h>

sem_t mutex;

/* create the semaphore */

sem_init( &mutex, 0, 1 );

/* acquire the semaphore */

sem_wait( &mutex );

/*** CRITICAL SECTION ***/

/* release the semaphore */

sem_post( &mutex );

Program Output

Your simulation should output when various conditions occur: buffer empty/full, location of producer/consumer, etc.

Submission Guidelines and Requirements

1. Your program must be written using C or C++ and you are required to use the Pthread with mutex and semaphore libraries

2. You may use the C/C++ STL (Standard Template Library) in your solution.

3. You should use Netbeans to implement the assignment. You can download Netbeans with C/C++ features from the following link: https://netbeans.org/downloads/8.2/

4. Create project in Netbeans for completing this assignment.

5. Add comments (about the function/variable/class) to your code as much as possible

6. Zip your project including source files and input/output text data files (if any)

7.  Upload the zipped project file onto Blackboard