TALLER ARQUITECTURA DE SOFTWARE
GA4-220501095-AA2-EV06
JUAN DAVID VILLALBA LOPEZ
SERVICIO NACIONAL DE APRENDIZAJE (SENA)
ANALISIS Y DESARROLLO DE SOFTWARE (ADSO)
IBAGUE TOLIMA
2023
Tabla de contenido
INTRODUCCION ............................................................................................................................................ 4
¿QUE ENTENDEMOS POR ARQUITECTURA DE SOFTWARE? ....................................................................... 4
¿CUAL ES LA FUNCION DE LA ARQUITECTURA DE SOFTWARE? .................................................................. 4
¿COMO SE ELEBORA LA ARQUITECTURA DE SOFTWARE? .......................................................................... 4
1. Requisitos del sistema: ..................................................................................................................... 5
2. Identificar los componentes claves:................................................................................................. 5
3. Definición de relaciones: .................................................................................................................. 5
4. Selección de tecnologías: ................................................................................................................. 5
5. Establecer patrones de diseño: ........................................................................................................ 5
6. Consideraciones de rendimiento: .................................................................................................... 5
7. Seguridad: ......................................................................................................................................... 5
8. Documentación: ............................................................................................................................... 5
9. Revisión y validación: ....................................................................................................................... 5
10. Iteración y evolución: ................................................................................................................... 6
¿COMO LOGRAR UNA BUENA ARQUITECTURA DE SOFTWARE? ................................................................ 6
A. Comprender los requisitos: .............................................................................................................. 6
B. Definir objetos de diseño: ................................................................................................................ 6
C. Seleccionar patrones de diseño: ...................................................................................................... 6
D. Divide y conquista: ........................................................................................................................... 6
E. Establece capas y responsabilidades: .............................................................................................. 6
F. Fomenta la modularidad: ................................................................................................................. 7
G. Garantiza la seguridad:..................................................................................................................... 7
H. Optimización de rendimiento: ......................................................................................................... 7
I. Documentación clara:....................................................................................................................... 7
J. Mantenimiento continuo: ................................................................................................................ 7
K. Formación y mejora:......................................................................................................................... 7
¿CUALES SON LOS ELEMENTOS DE DISEÑO DE UNA ARQUITECTURA DE SOFTWARE? ............................. 7
a) Componentes: .................................................................................................................................. 8
b) Relaciones: ........................................................................................................................................ 8
c) Patrones de diseño: .......................................................................................................................... 8
e) Interfaces: ......................................................................................................................................... 8
f) Flujo de datos: .................................................................................................................................. 8
g) Decisiones tecnológicas: .................................................................................................................. 8
h) Seguridad: ......................................................................................................................................... 9
i) Rendimiento: .................................................................................................................................... 9
j) Documentación: ............................................................................................................................... 9
CONCLUSIONES............................................................................................................................................. 9
INTRODUCCION
La arquitectura de software es el esqueleto invisible pero fundamental detrás de todas las aplicaciones y
sistemas informáticos que utilizamos a diario. Es la disciplina que define como se estructuran y organizan
los componentes de un software, influenciando su rendimiento, mantenibilidad, y capacidad de
adaptación. En otras palabras, es el diseño maestro que da forma y cohesión a un sistema de software.
En este mundo cada vez mas interconectados y dependiendo de las tecnologías, comprender y dominar
la arquitectura de software se ha convertido en un requisito esencial para desarrolladores, ingenieros y
arquitectos del software. Este taller de arquitectura software explicara de una manera mas simplificada
los conceptos fundamentales de la arquitectura del software.
¿QUE ENTENDEMOS POR ARQUITECTURA DE SOFTWARE?
La arquitectura de software se refiere a la estructura fundamental y la organización de un sistema de
software. Es el diseño de alto nivel que define como los diferentes componentes de software interactúan
entre sí, como se comunican y como se distribuyen en un sistema o aplicación informática, la
arquitectura del software establece la base sobre la cual se desarrolla y opera un sistema, y tiene un
impacto significativo en su rendimiento, mantenibilidad, escalabilidad y flexibilidad.
¿CUAL ES LA FUNCION DE LA ARQUITECTURA DE SOFTWARE?
El objetivo principal de la arquitectura del software es la de proporcionar una visión de alto nivel y una
estructura solida para el desarrollo de sistemas y aplicaciones informáticas, asegurando que cumplan
con los requisitos, sean eficientes y puedan adaptarse a los cambios a lo largo del tiempo.
¿COMO SE ELEBORA LA ARQUITECTURA DE SOFTWARE?
La elaboración de la arquitectura del software es un proceso clave en el desarrollo de sistemas y
aplicaciones informáticas. Pese que el patrón en una arquitectura de software es distinto en los casos
aquí hay un conjunto de pasos que se pueden seguir para crear una arquitectura de software efectiva:
1. Requisitos del sistema:
Comenzamos por comprender los requisitos del sistema, esto implica reunir y analizar los
requisitos funcionales y no funcionales del software, así como comprender las necesidades del
usuario o cliente. Esta etapa es crucial para definir el propósito y los objetivos del sistema.
2. Identificar los componentes claves:
Identifica los componentes principales que formaran parte de la arquitectura del software. Esto
puede incluir módulos, subsistemas, bases de datos, interfaces de usuario, servicios web, entre
otros. Organiza estos componentes de manera lógica.
3. Definición de relaciones:
Establece como se relacionan estos componentes entre sí. Definen las interfaces y los protocolos
de comunicación que utilizaran para intercambiar datos y colaborar. Esto incluye la elección de
patrones de diseño arquitectónico, como MVC (Model-View-Controller) o microservicios.
4. Selección de tecnologías:
Elige las tecnologías y herramientas adecuadas para implementar los componentes y las
relaciones definidas en la arquitectura. Esto puede incluir lenguajes de programación, base de
datos, frameworks, plataformas de desarrollo, entre otros.
5. Establecer patrones de diseño:
Aplica patrones de diseño de software para abordar problemas comunes de diseño de manera
efectiva. Estos patrones proporcionan soluciones probadas y optimizadas para problemas
específicos.
6. Consideraciones de rendimiento:
En este punto se debe tener en cuenta las consideraciones de rendimiento desde el principio.
Evalúa como se comportará el sistema en términos de velocidad capacidad y escalabilidad. Esto
podría implicar la implementación de técnicas de cache, optimización de consultas de bases de
datos y escalabilidad horizontal y vertical.
7. Seguridad:
Diseña la arquitectura con la seguridad en mente. Considera las amenazas potenciales y
establece medidas de seguridad adecuadas, como autenticación, autorización, encriptación, y
prevención de ataques.
8. Documentación:
Documenta la arquitectura de software de manera clara y completa. Esto incluye diagramas de
arquitectura, descripciones de componentes y relaciones, así como cualquier otra información
relevante que ayude a los desarrolladores a comprender y trabajar con la arquitectura.
9. Revisión y validación:
Realiza revisiones y validaciones periódicas de la arquitectura con otros miembros del equipo,
arquitectos y partes interesadas. Esto ayuda a identificar problemas o deficiencias antes de
avanzar en el desarrollo.
10. Iteración y evolución:
La arquitectura de software no es estática; debe evolucionar a medida que el proyecto avanza y
los requisitos cambian. Esta preparado para realizar ajustes y mejoras en la arquitectura a lo
largo del ciclo de vida del software.
¿COMO LOGRAR UNA BUENA ARQUITECTURA DE SOFTWARE?
Lograr una buena arquitectura de software es esencial para el éxito de cualquier proyecto de desarrollo
de software. Aquí hay algunos pasos y prácticas que pueden ayudarte a lograr una arquitectura de
software sólida:
A. Comprender los requisitos:
Antes de comenzar a diseñar la arquitectura, debes comprender completamente los requisitos del
sistema. Esto incluye los requisitos funcionales (qué debe hacer el software) y los requisitos no
funcionales (cómo debe hacerlo, como el rendimiento, la seguridad y la escalabilidad). Mantén una
comunicación constante con los stakeholders (clientes, usuarios, etc.) para asegurarte de que todos los
requisitos estén claros y documentados.
B. Definir objetos de diseño:
Establece objetivos de diseño claros para la arquitectura. ¿Qué cualidades deseas en tu sistema? Por
ejemplo, ¿debe ser altamente escalable, seguro o fácilmente mantenible? Estos objetivos guiarán tus
decisiones de diseño.
C. Seleccionar patrones de diseño:
Utiliza patrones de diseño de software probados y aceptados. Estos patrones ofrecen soluciones
comunes a problemas de diseño y ayudan a mantener la coherencia en la arquitectura.
D. Divide y conquista:
Divide el sistema en módulos o componentes más pequeños y manejables. Esto facilita el diseño, la
implementación y el mantenimiento. El principio de responsabilidad única (Single Responsibility
Principle) de SOLID es útil aquí.
E. Establece capas y responsabilidades:
Organiza el sistema en capas lógicas, como la capa de presentación, la capa de lógica de negocio y la
capa de acceso a datos. Cada capa debe tener responsabilidades claras y estar bien definida.
F. Fomenta la modularidad:
Diseña componentes y módulos que sean independientes y acoplados de manera débil. Esto permite
reutilizar, probar y mantener partes del sistema de manera más efectiva.
G. Garantiza la seguridad:
La seguridad debe ser una parte integral de la arquitectura. Incorpora prácticas de seguridad, como
autenticación, autorización y manejo seguro de datos, desde el principio.
H. Optimización de rendimiento:
Considera las consideraciones de rendimiento desde el principio y utiliza técnicas de optimización
cuando sea necesario. Esto puede incluir la implementación de caché, la gestión eficiente de recursos y
la escalabilidad.
I. Documentación clara:
Documenta la arquitectura de manera exhaustiva. Esto incluye diagramas, descripciones de
componentes, interfaces y relaciones, así como cualquier justificación detrás de las decisiones de diseño.
J. Mantenimiento continuo:
La arquitectura no es estática. Debes estar preparado para realizar ajustes y mejoras a medida que
evoluciona el proyecto y cambian los requisitos.
K. Formación y mejora:
Invierte en la formación continua de tu equipo para mantenerse al tanto de las mejores prácticas y
tendencias en arquitectura de software.
¿CUALES SON LOS ELEMENTOS DE DISEÑO DE UNA ARQUITECTURA DE
SOFTWARE?
Los elementos de diseño de una arquitectura de software son los componentes, las decisiones y las
estructuras clave que componen la estructura y el diseño general del sistema de software. Estos
elementos se combinan para crear una base sólida que cumple con los requisitos del proyecto y
garantiza la calidad, el rendimiento y la mantenibilidad del software. Los elementos de diseño más
importantes de una arquitectura de software incluyen:
a) Componentes:
Los componentes son unidades lógicas y funcionales del sistema que realizan tareas específicas.
Pueden ser módulos de software, subsistemas, servicios, objetos, funciones o cualquier otra
entidad que realice una función en el sistema. La identificación y la definición clara de los
componentes son esenciales para organizar y estructurar el sistema.
b) Relaciones:
Las relaciones entre los componentes describen cómo interactúan y se comunican entre sí. Esto
incluye las dependencias entre componentes, como la llamada a funciones o métodos, así como
las conexiones de red, las interfaces de usuario y cualquier otra forma de interacción.
c) Patrones de diseño:
Los patrones de diseño son soluciones probadas y comunes a problemas de diseño específicos.
Pueden aplicarse a nivel de componente o a nivel de sistema para resolver desafíos recurrentes
de diseño de software. Ejemplos de patrones de diseño incluyen el patrón Singleton, el patrón
MVC (Model-View-Controller) y el patrón Factory, entre otros.
d) Capas:
La arquitectura de software a menudo organiza los componentes en capas lógicas. Cada capa
tiene una responsabilidad específica en el sistema y se comunica con otras capas de manera
controlada. Por ejemplo, una arquitectura en capas típica puede incluir una capa de
presentación, una capa de lógica de negocio y una capa de acceso a datos.
e) Interfaces:
Las interfaces definen cómo los componentes se comunican entre sí. Esto incluye la
especificación de métodos, funciones y protocolos de comunicación que deben seguirse para
que los componentes interactúen de manera efectiva.
f) Flujo de datos:
Los flujos de datos describen cómo los datos se mueven a través del sistema. Esto incluye cómo
se recopilan, almacenan, procesan y transmiten los datos dentro del sistema y con sistemas
externos.
g) Decisiones tecnológicas:
Las decisiones de tecnología se refieren a las elecciones de herramientas, lenguajes de
programación, bases de datos y plataformas que se utilizarán en el diseño y la implementación
del sistema.
h) Seguridad:
La seguridad es un elemento crítico de diseño. Esto incluye la implementación de medidas de
seguridad como autenticación, autorización, cifrado y control de acceso para proteger los datos
y el sistema en su conjunto.
i) Rendimiento:
El diseño de arquitectura debe considerar el rendimiento del sistema, incluyendo la optimización
de consultas de base de datos, el uso eficiente de recursos y la escalabilidad para manejar la
carga prevista.
j) Documentación:
La documentación clara y detallada es esencial para comprender y mantener la arquitectura de
software. Esto incluye diagramas de arquitectura, descripciones de componentes y relaciones, y
cualquier otra información relevante.
CONCLUSIONES
En conclusión, la arquitectura de software es un elemento crítico en el desarrollo de sistemas y
aplicaciones informáticas exitosas. Proporciona la base estructural sobre la cual se construyen soluciones
tecnológicas robustas y eficientes.
En última instancia, una buena arquitectura de software no solo satisface las necesidades del presente,
sino que también prepara el terreno para el crecimiento futuro y la innovación. Al seguir las mejores
prácticas y los principios de diseño, los arquitectos de software pueden contribuir significativamente al
éxito de proyectos tecnológicos y asegurar que las soluciones informáticas sean sólidas, seguras y
sostenibles a largo plazo.
