Repository navigation
IT System Arcitecture
IT System Architecture ATM
This documnet decribes the IT system architectur, how the architecure fullfill the requirments and how the IT system architecture impacts the development, deployment and operation of the ATM IT system.
To minimize the lifetime cost of the IT system. To maximise the team members productivity. Easy to understand Easy to develop Easy to maintain Easy to deploy Easy to fullfill stakolder needs with IT system Easy to fullfill requirments with the IT system Esay to verify the IT capabilities of the IT system Easy to obtain buisness values of the IT system
IT System Architecture represents the significant descision that shape a IT system where significant in is measured in cost of change. The measure to structural quality is the measure of effort required to meet the needs of the stakeholders. If the effort is low and stays low throughout the lifetime of the system, the design is good. If that effort grows with each new release, the design is bad.
Architecture of a IT system is shaped by those that developed, deploy and operate it. The purpose of the shape is to facilitate the development, deployment, operation and information feedback of the IT system. The form of that shape is the division of that IT system into components, the arrangment of those component, and the way inn those component communicate communicate with each other. The strategy is to leave as many options open as possible, for as long as possible.
The ATM system will be an enterprise IT system. Enterprise IT system are about the display, manipulation, and storage of large amounts of often complex data and the support or automation of business processes with that data.
Enterprise software should satisfy the needs of an organization.
Some of the problems that can occure when one develope and operate of a enterprise software system are • The complexity and fragmentation of IT landscapes • Ever-changing business processes and requirements • The need to learn and integrate new technologies, such as big data, cloud, etc. • Lack of engament from stakeholders • Difficult to change the legacy IT systems. The cost of implementing changed requirements can get higher than the buisnesss value. • Much of the software development resources is used to replace legacy systems
Our experience has shown that deploying a brand new software product into production can take the better part of a week for a complex new IT system.That’s not very productive, and even though DevOps practices work to alleviate some of the barriers, it often requires a lot of effort and communication between teams of people. This process can often be both technically challenging and expensive, but even worse, it can limit the kinds of innovation that development teams will undertake in the future. If deploying software product is hard, time-consuming, and requires resources from another team, then team members will often build everything into the existing application in order to avoid suffering the new deployment penalty
The righ arcitecture depends on the deployment environment, business drivers, company culture, budgets, timeframes, developer skill set, and dozens of other factors. Everyone’s environment, situation, and problem is different, hence why architecture is so hard. In order to know what to develope must the stakeholders needs be expressed in requirments descibed by the arciitecure characteristieces described above. One part of architecure work is to find a architecture that fullfill the charatestics. The different characteriestices are depenedents on each other so one need to do trade-offs in order to fullfill the characterisichs.
An architecture characteristic meets three criteria:
- Specifies a nondomain design consideration
- Influences some structural aspect of the design Is critical or important to application success
Richards, Mark,Ford, Neal. Fundamentals of Software Architecture (Kindle Locations 1006-1007). O'Reilly Media. Kindle Edition.
Merges and Aquasition
- Interorability
- Scaleability
- Adaptability
Time To Market
- deployability,
- testability,
- evolvability
User satisfaction
- Performance
- Availability
- Fault Tolerance
- Testability
- Deployability
- Evolvability
- Security
Competetive Advanteges
- Evolvability
- Testability
- Deployability
- Scaleability
- Availability
- Fault tolerance
Time and and Budget
- Simplicity
- Feasability
Increase Productivity • Easye to to changes mainttainablity, • Testablity Deployability
Increase Visisbility • Quality • Report from the automatic test exeution • Code quality repotrting • Progress • Repoort on definition done
In order to know what to develope must the stakeholders needs be expressed in requirments descibed by the arciitecure characteristieces described above. One part of architecure work is to find a architecture that fullfill the charatestics. The different characteriestices are depenedents on each other so one need to do trade-offs in order to fullfill the characterisichs.
Want to develope the system in java.
Alternative framworks JEE
The quality attributes is affected by the software development prosess, desing, implementaion , and deployment.
Development of the Architecture Started with the domain model as pojo, the cucumber scenario as automatic spesification and system test, junit as unit and integration test. All the code was defined in one project
Added win in the same project
Wanted to store the data persistent. Seleted use of the spring jpa to avoid a lot of boiler plate programing(productivity, reliability, maintainability, portability)-
Wanted to web as gui (Split into multimodel project, selected wicket as the web framwork ( Testability, Reliability,Maintainability)
Neded Mocks to test the service layer unit test. Selected mockito because it was integrated in spring .
Non functional requirment
Deplployaility
Portability
Testability
Improved testability of dependent classes
CustomerService class holds reference to the CustomerRepository interface. FixedDepositJdbcDao and FixedDepositHibernateDao are concrete implementation classes of CustomerRepository interface. Unit testing of CustmerService class, you can substitute a mock implementation of CustmerRepository interface. The unit test doesn’t require a database. If the CustmerService class had direct reference to FixedDepositJdbcDao or FixedDepositHibernateDao class, testing FixedDepositService class would have required setting up a database for testing purposes. This shows that by using a mock implementation of dependency interface, you can save the effort to setup the infrastructure for unit testing your dependent classes.
Maintainability • Analysebility • Testability
Reliability • Maturity • Freqent Automatic Regression testing( Bug repellent)
Efficiency
Time To Market The system must be maintainablility, te
Productivity • Easye to to changes mainttainablity, Visisbility • Quality • Report from the automatic test exeution • Code quality repotrting • Progress • Repoort on definition done
Agility • Maintainaable, Testability • Test
Principels: • Don’t distribute before it is nessesary • Take arcitecural decition as late as posibble • Try desing the system so that few architctual decition is needed (flexible system) • Use java as much as possible • Use open software as much as possible • Replace problem parts • Support cross functional team that completes features on by one • Use product that have a large community and amongst the most used. • Possibility to delivery often • Keep the testcode out of production code • As much as possible of configuration in code instead of file or annotation • Keep mocking at a mininmum • Write test first • Test are eksampels • State verification • Fixturedesing by a test to test basis • Test one at the time • Test is basis for the next layer • Declare with import all dependencies of the class • Itrative and incrementail quantification of the quality attributes • SOLID principles tells us how to arrange our functions and data structures into classes and how classes should be interconnected. Class is a coupled grouping of function and data. The goal of the principles is the creation of mid-level software stuctures that:
-
Tolerate change
-
Are easy to understand
-
Are the basis of components that can be used to many software systems
The Singel Responsiblility Principle Open-Close Principle The Liskov Substitution Principles The Interface Substitution Principles The interface Segregation Principles The Dependicy Inversion Principles
Compoent cohesion principles The Reuse/Relase Equivivalence Principle (Group for reuse) The grannule of reuse is the grannule of relase.
The common closure principle (Group for maintance)
Gather into the component those classes that change for the same reasons and at the same times. Separate into different components those classes that change at different times and for different reasons.
The common reuse principle (Split to avoid uneeded relases)
Do not force users of a component to depend on things they don't need.
Focus on REP and CRP . To many components are impacted when simple changes are made. Focus on CCP and REP To many uneeded relases to be generated.
- Follow the AWS Principles for well arcitected
- Follow the Desing Principles of AWS principles of well archiected
With the model can a bank manage bank accounts for customer, and customers can interact with the ATM. The ATM class handle the states for interacting with customer for withdraw of money. The GUI and the system tests communicate with ATM class. The BankAccount and Customer are Entities (Evans, 2004) identified Bank Account by id and Customer by customer number. This system is created for one bank so class Bank will be a Singleton (Gamma, 1995).
Software Arcitecture
Goal: To minimize the human resources required to develop and operate the required IT system.
The measure to design quality (structure quality) is the measure of effort required to meet the needs of the stakeholders. If the effort is low and stays low throughout the lifetime of the system, the design is good. If that effort grows with each new release, the design is bad
Use of frameworks the are use by many and have a county the developer
Support achievement of devops goals
Maiintinablire Tolerate change Easy to undertsad Basis for compnents that can be used in many sofware system Leranability Testability Performance Security
Ease of automation.
Evelutionalt architectire
12 Factore Arcitecture Solid Principles
All code, configuration and documentation should be stored in a version controll system
Layered Architecture
Presentaion Layer PresntationService Layer Controller Layer Service Layer Repository Layer Data Base Layer
Deployability 1 Elasticity 1 Evolonary 1 Fault tolerance 1 Modularity 1 Overall cost 5 Performance 🎭 2 Reliability 3 Scaleability 1 Simplicety 5 Testability 2
Overall cost and simplicity are the primary strengths of the layered architecture style. Being monolithic in nature, layered architectures don’t have the complexities associated with distributed architecture styles, are simple and easy to understand, and are relatively low cost to build and maintain. However, as a cautionary note, these ratings start to quickly diminish as monolithic layered architectures get bigger and consequently more complex. Both deployability and testability rate very low for this architecture style. Deployability rates low due to the ceremony of deployment (effort to deploy), high risk, and lack of frequent deployments. A simple three-line change to a class file in the layered architecture style requires the entire deployment unit to be redeployed, configuration changes, or other coding changes sneaking in alongside the original change. Furthermore, this simple three-line change is usually bundled with dozens of other changes, thereby increasing deployment risk even further (as well as increasing the frequency of deployment). The low testability rating also reflects this scenario; with a simple three-line change, most developers are not going to spend hours executing the entire regression test suite (even if such a thing were to exist in the first place), particularly along with dozens of other changes being made to the monolithic application at the same time. We gave testability a two-star rating (rather than one star) due to the ability to mock or stub components (or even an entire layer), which eases the overall testing effort. Overall reliability rates medium (three stars) in this architecture style, mostly due to the lack of network traffic, bandwidth, and latency found in most distributed architectures. We only gave the layered architecture three stars for reliability because of the nature of the monolithic deployment, combined with the low ratings for testability (completeness of testing) and deployment risk. Elasticity and scalability rate very low (one star) for the layered architecture, primarily due to monolithic deployments and the lack of architectural modularity. Although it is possible to make certain functions within a monolith scale more than others, this effort usually requires very complex design techniques such as multithreading, internal messaging, and other parallel processing practices, techniques this Elasticity and scalability rate very low (one star) for the layered architecture, primarily due to monolithic deployments and the lack of architectural modularity. Although it is possible to make certain functions within a monolith scale more than others, this effort usually requires very complex design techniques such as multithreading, internal messaging, and other parallel processing practices, techniques this architecture isn’t well suited for. However, because the layered architecture is always a single system quantum due to the monolithic user interface, backend processing, and monolithic database, applications can only scale to a certain point based on the single quantum. Performance is always an interesting characteristic to rate for the layered architecture. We gave it only two stars because the architecture style simply does not lend itself to high-performance systems due to the lack of parallel processing, closed layering, and the sinkhole architecture anti-pattern. Like scalability, performance can be addressed through caching, multithreading, and the like, but it is not a natural characteristic of this architecture style; architects and developers have to work hard to make all this happen. Layered architectures don’t support fault tolerance due to monolithic deployments and the Layered architectures don’t support fault tolerance due to monolithic and the lack of architectural modularity. If one small part of a layered architecture causes an out-of-memory condition to occur, the entire application unit is impacted and crashes. Furthermore, overall availability is impacted due to the high mean-time-to-recovery (MTTR) usually experienced by most monolithic applications,
Richards, Mark,Ford, Neal. Fundamentals of Software Architecture (Kindle Locations 2702-2707). O'Reilly Media. Kindle Edition.
Richards, Mark,Ford, Neal. Fundamentals of Software Architecture (Kindle Locations 2697-2703). O'Reilly Media. Kindle Edition.
Richards, Mark,Ford, Neal. Fundamentals of Software Architecture (Kindle Locations 2692-2697). O'Reilly Media. Kindle Edition.
Richards, Mark,Ford, Neal. Fundamentals of Software Architecture (Kindle Locations 2689-2696). O'Reilly Media. Kindle Edition.
Richards, Mark,Ford, Neal. Fundamentals of Software Architecture (Kindle Locations 2682-2688). O'Reilly Media. Kindle Edition.
Compinents provides a clean separation of responsibilities and encapsulation of dependencies, which results in a boost in productivity. It also allows fine-grained control by putting team members in control of everything, down to the OS distribution on which they ship their software product. get the job done, while still being built from interchangeable parts that can easily be swapped in and out to support custom solutions. By using an image repository as the hand-off point, Docker allows the responsibility of building the application image to be separated from the deployment and operation of the container. What this means in practice is that development teams can build their application with all of its dependencies, run it in development and test environments, and then just ship the exact same bundle of application and dependencies to production. Because those bundles all look the same from the outside, operations engineers can then build or install standard tooling to deploy and run the applications tools to come with everything most people need to Deployment prosess
- Developers build the Docker image and ship it to the registry.
- Operations engineers provide configuration details to the container and provision resources.
- Developers trigger deployment.
This is possible because Docker allows all of the dependency issues to be discovered during the development and test cycles. By the time the application is ready for first deployment, that work is done. And it usually doesn’t require as many handovers between the development and operations teams. That’s a lot simpler and saves a lot of time. Better yet, it leads to more robust software through testing of the deployment environment before release.
deploying a Docker container to a heterogeneous mix of cloud providers at the same time. This kind of orchestration has not been easy before, and it seems likely that as these major companies continue to invest in the platform, the support and tooling will improve correspondingly. So that covers Docker containers and tooling, but what about OS vendor support and adoption? The Docker client runs directly on most major operating systems, but because the Docker server uses Linux containers, it does not run on non-Linux systems. Docker has traditionally been developed on the Ubuntu Linux distribution, but most Linux distributions and other major operating systems are now supported where possible. When Docker was barely two years old, it already had broad support across many platforms. With the creation of The Open Container Initiative in June of 2015, there is a lot of hope for a well-developed indsutry standard for containers and Docker’s continued growth into the future.
Tires Frontend tire Backend tire Database tire
Docker
Deployabe
Prodictive (Easuere
Reliability
Portability Easier to places in different eneviromet (Os, Programming laguage, isolated)
ATM presentaion Thires
Enviroment
Logging
Mocking
Test Result Reporting
ATM Microservice
Enviroment
Logging
Mocking
Test Result Reporting
Bank Microservice
MicroService ATM Bank
Vise kall struktur
Deployment Igress Frontend Service Frontend Deployment Backend Service Backend Deployment Database Service Database Deployment
Domain Model Deployment Model Impl
Service Discovery Service Discovery Mechannisme Load Balances Ingress
Broker Decople and interoperating components rather than monolitic application result in greater flexibility, maintainabilty and changeability (s 100 POSA). By partision functionality into independent components the system becomes potential distributable and scaleable WWW Browser http request frontend component, websereer React Componenets HTML/Javascript Javascript Fetch, REST , HTTP (Frontend Component,Pods Node, Backend Service, Bakend Pod, Node Compoenet, Spring Boot RestController, Java)
Grater
Layer Frontend Controller Repository Model View Controller Service Session? Transaction