Spaces:
Runtime error
Runtime error
| [{ | |
| "47431449K": { | |
| "respuesta_completa": "Una arquitectura Réplica-Set permite implementar, tal como indica su nombre, la replicación de datos de una base de datos a otra. Esto, además de para tener una base de datos como respaldo, sirve como método de recuperación automático de datos cuando se produce un fallo. \nLa arquitectura de Réplica-Set necesita como mínimo tres nodos; el primario, el secundario y el árbitro. La función del nodo árbitro es la de decidir cuál de los otros dos nodos es el primario y cuál el secundario.\nCuando el nodo primario deja de tener disponibilidad, el nodo secundario asume su función.\nLa principal diferencia con mongodump es que éste realiza una copia de seguridad de los datos cuando se ejecuta el correspondiente comando, mientras que la arquitectura Réplica-Set se encuentra constantemente replicando los datos entre los dos nodos.", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "61d68c1e8cd66a2cff6b98a539a30d37" | |
| }, | |
| "47855702Q": { | |
| "respuesta_completa": "Cuando hablamos de Replica-set, nos referimos a la generación de una BBDD a partir de un volcado de datos. Esto implica que mínimo tienen que haber 2 servidores (puede que haya 3 o más). En el caso de que hubieran tres el primario es donde se escribiría y los otros dos (secundarios) recibirían actualizaciones inmediatas de los datos, es decir se realizan replicas inmediatas. \nReplica set nos permite tener una mayor disponibilidad, ya que en el caso de fallo del servidor primario, es decir, dejara de enviar heartbeats, uno de los secundarios pasaría a ser primario. La elección se hace a través de un proceso de votación y en el caso de que hubiera empate, sería el nodo árbitro quien decidiría quien es el primario. \nAsimismo, ofrece respaldo porque ante una caída del primario siempre se tendrá una copia de los datos. Aunque no nos protege de la inserción o borrado de datos, por ese motivo es importante contar con un dump. Mongodump realiza un volcado de datos y se almacena en el disco duro, generando archivos BSON o JSON de la BBDD. \nPor último, ofrece balanceo de carga, ya que el primario propaga los datos pero la lectura puede ser en el primario o en los secundarios. Este proceso es transparente al cliente. ", | |
| "m1_score": 1.0, | |
| "m2_score": 1.0, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "b5372c107dc97e91722398e3a9b57f08" | |
| }, | |
| "79002636M": { | |
| "respuesta_completa": "Un replica-set es una configuración de servidores de replicación. Puedes tener 1 nodo primario y n secundarios. Para configuración mínima hacen falta 1 primario y dos secundarios. El primario es un servidor de MongoDB donde escribes y lees y los secundarios están conectados al primario de tal forma que cada vez que el primario recibe un dato lo propaga a los secundarios, de tal forma que tenemos copias en tiempo real. \nAnte una corrupción del primario siempre tendremos una copia de los datos.\nSi el primario deja de funcionar uno de los secundarios se convierte en primario. La elección del nuevo primario se hace a través de una votación de los secundarios y cuando el que era primario se reconecte será secundario.\nUna ventaja del replica-set es el balanceo de carga ya que la escritura siempre será desde el primario, pero la lectura puede ser desde los secundarios.\nLa principal diferencia con mongodump es que con este lo que obtenemos es una foto de los datos es decir que si modificamos algo después de haber hecho el dump la copia anterior quedará desactualizada y con replica-set tenemos siempre una copia actualizada de los datos.", | |
| "m1_score": 1.0, | |
| "m2_score": 1.0, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "d2b0d015ec81981be5ac318b6ff2c30e" | |
| }, | |
| "02739491F": { | |
| "respuesta_completa": "Una arquitectura replica set en mongo DB permite realizar backup de los documentos de una colección determinada con la que estamos trabajando. La principal diferencia con mongo dump es que este último crea una copia de seguridad completa de todas las colecciones de nuestra BBDD y con un replica set estamos replicando automáticamente la información de una colección determinada, especificada por nosotros en los ficheros de configuración de nuestro replica-set. Son necesarios tres nodos para una configuración mínima: un nodo primario que decide cuál es la información que se ha de replicar, un nodo secundario que replica la información indicada por el primario y un nodo árbitro es el encargado de decidir qué nodo es primario y cuál es secundario. Esta situación ocurre cuando el nodo primario deja de tener disponibilidad: el árbitro observará los nodos existentes y decidirá quien ha de ser el nuevo nodo primario en función de la disponibilidad de la que dispongan", | |
| "m1_score": 0.75, | |
| "m2_score": 0.5, | |
| "m3_score": 0.75, | |
| "m4_score": 0.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "d53c53e45fe8364078094fe28ec52c6f" | |
| }, | |
| "32082430Y": { | |
| "respuesta_completa": "Replica-Set es una característica de MongoDB que permite la redundancia de datos e incrementar la disponibilidad de los datos. Esta arquitectura está basada en un modelo Maestro-Esclavo.\nEste modelo permite la recuperación de fallos de forma automática, y es la forma de implementar la replicación de datos en mongoDB.\nLa forma de configurar un replica-set es atreves de tres nodos, dos nodos serán instancias de mongod con acceso a los datos que replicarán los datos del nodo primario, mientras que uno de ellos será el nodo primario sobre el que se realizarán las consultas y modificaciones.\nEn caso de que el nodo primario deje de tener disponibilidad, uno de los otros dos nodos secundarios pasa a ser el primario a través de una votación. Para este tipo de votaciones se suele asignar a uno de los dos secundarios como árbitro, con prioridad 0 sobre los demás y se encargará de desempatar.\nA diferencia de mongodump, que se centra sobre todo en guardar backups de los datos, Replica-Set es una arquitectura robusta frente a fallos, y el proceso de replicación o backup en los nodos secundarios se realiza automáticamente.", | |
| "m1_score": 1.0, | |
| "m2_score": 1.0, | |
| "m3_score": 1.0, | |
| "m4_score": 0.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "b05a860f2007c94a3ee35a06752a5c14" | |
| }, | |
| "45891666L": { | |
| "respuesta_completa": "Replica set permite una recuperación a fallos de forma automática, y es la forma más adecuada de implementar replicación de datos en MongoDB. Son necesarios 3 nodos: dos nodos son instancias de mongod con acceso a los datos, uno de los nodos será el primario y el otro replica las operaciones que se realizan en el primario. Y el tercer nodo se llama árbitro, se utiliza solo para decidir qué nodo debe ser el primario. Cuando el nodo primario no tiene disponibilidad, este se cambia por el nodo con disponibilidad, para saber la disponibilidad se envían pings cada dos segundos. Mongodump realiza una copia de seguridad de los datos conectándose a una instancia de mongod, mientras que replica-set esta directamente conectado con otro nodo en el cual se hace la replicación en cada operación automáticamente", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "f67d6366cd6c0b9e461783351902eefe" | |
| }, | |
| "71453891-K": { | |
| "respuesta_completa": "El concepto de Replica-set es un refinamiento del modelo Maestro-esclavo, las funciones principales del conjunto de réplicas es permitir la recuperación a fallos de manera automática y es una de las formas de añadir replicación a datos en MongoDB. \nLa recomendación en replica-set es de una configuración mínima de tres nodos. En este caso uno de ellos es el nodo primario, sobre este nodo actúa un nodo secundario que replicará las operaciones que se vayan a realizar en el primario, por lo que actuará en caso de no disponibilidad del primario. \nUno de los métodos de respaldo es mongodump este hace una copia de seguridad en ese instante de los datos conectándose a una instancia mongo que se esté ejecutando, por otro lado, con las réplicas mantienen la información duplicada en todo momento por varios nodos.", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 0.5, | |
| "m4_score": 0.25, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "d0d16cf33b031602f1b818a8190fc59f" | |
| }, | |
| "50345097Y": { | |
| "respuesta_completa": "La principal aplicación de Replica-Set en MongoDB es la de proporcionar respaldo a los datos. Está basado en un modelo maestro-esclavo. En esta arquitectura existe la figura de un nodo primario (nodo maestro). Esta figura no es estática, los nodos se intercambian pings cada dos segundos para conocer la disponibilidad de cada uno. El número mínimo de nodos que se necesitan para un Replica-Set en MongoDB son tres nodos. Dos nodos son nodos de datos, donde uno es el primario y otro el secundario (réplica del primario). El tercer nodo es un nodo árbitro. En caso de que el nodo primario deje de tener disponibilidad, este nodo árbitro asignará la función de nodo primario a otro nodo. La principal diferencia con mongodump es que este comando lleva a cabo una foto estática de la base de datos en el momento en el que se ejecuta, y extrae unos ficheros BSON y JSON con los datos que se encuentran en la BBDD en el momento de la ejecución. Por su parte, Replica-Set funciona en tiempo real, es decir, los datos se encuentran respaldados continuamente, lo que conlleva una menor pérdida de datos en caso de incidencia", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 0.5, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "2e7405e83d52a3f78f50c8ca6f16d961" | |
| }, | |
| "12425296y": { | |
| "respuesta_completa": "La función de un replica-set es permitir la redundancia de datos, incrementando así la disponibilidad siguiendo un modelo maestro-esclavo. Para una mínima configuración es necesario que existan 3 nodos, uno principal y dos secundarios (el nodo principal manda replicas a los nodos secundarios y así se consigue una “copia de seguridad” en caso de caída del principal) uno de los secundarios tomará el papel de árbitro en el caso de que haya una caída, ya que cuando el nodo principal deja de tener disponibilidad, será uno de los nodos secundarios el que pase al puesto de principal. Esto puede dar lugar a empate, es por ello que se establece un árbitro.\nEs importante tener en cuenta la diferencia con mongoDump. Mongodumop realiza una copia de seguridad fija (se puede hacer símil a una foto), mientras que el replica-set sufre cambios en “streaming”. Se actualiza constantemente", | |
| "m1_score": 1.0, | |
| "m2_score": 1.0, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "b8af34d45326efd631958c2e4c4ca125" | |
| }, | |
| "72102993V": { | |
| "respuesta_completa": "Un mecanismo que nos sirve para aumentar la disponibilidad es la replicación de información. Esto, consiste en replicar o distribuir los datos de los que disponemos. La arquitectura Replica-Set nos sirve para replicar el conjunto de datos en varias instancias o servidores para aumentar la disponibilidad de los datos. Esto se consigue creando nodos que repliquen la información para que, en caso de caída de uno de los nodos o pérdida, esta siga disponible. Pese a que en otras técnicas de replicación la configuración mínima consiste en dos nodos, uno principal y otro secundario, en el replica-set en mongodb la configuración está conformada por tres nodos, uno principal, otro secundario y un tercero que actúa como árbitro (desempate) en las votaciones. En caso de que el primario se caiga, el nodo secundario se convierte en primario. La principal diferencia con mongodump es que la replicación de la información es dinámica, es decir, no tienes que ejecutar un comando para realizar la copia de seguridad ni otro para recuperarla", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "07dcf54484cec166857559a76ff4afe8" | |
| }, | |
| "51106382Z": { | |
| "respuesta_completa": "Consiste en un mecanismo mediante el cual, se tiene una recuperación automática frente a fallos a través de la redundancia de los datos. El mecanismo se basa en tener un nodo primario que va replicando sus datos a los nodos secundarios, estos se ocuparán en todo momento de tener una copia actualizada de dichos datos, de este modo en caso de fallo del nodo primario, alguno de estos sea elegido como el nuevo nodo primario y de este modo se logre alta disponibilidad frente a fallos. Los nodos secundarios pueden ser de tipo: prioridad 0 los cuales no pueden ser primarios, ocultos, retrasados o árbitros.\nAdemás de la redundancia de los datos y la alta disponibilidad, esta arquitectura nos aporta la ventaja de balancear la carga automáticamente entre los nodos del replica-set en caso de lectura, aumentando así el rendimiento. Cabe destacar que para la escritura únicamente se usa el nodo primario.\nA la hora de tener una configuración mínima, se requiere un mínimo de 3 nodos, los cuales son 1 primario y 2 secundarios.\nLa principal diferencia con mongodump es que a pesar de poderse replicar los datos y, restaurar con mongostore, es un proceso manual y con la configuración replica-set se tiene una recuperación automática frente a fallos", | |
| "m1_score": 1.0, | |
| "m2_score": 1.0, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "79afddaced6c773e45347fd7982fb54d" | |
| }, | |
| "54294839G": { | |
| "respuesta_completa": "En MongoDB se ha hecho un refinamiento sobre el modelo “Maestro-Esclavo” y se le ha definido como conjunto de replicas o replica-set. Este permite una recuperación a fallos de forma automática, y es la forma recomendada de implementar replicaciones de datos en MongoDB.\nUna característica principal es que no definen un nodo maestro estéticamente, sino que es asignado al azar y esta asignación se actualiza dependiendo de la disponibilidad del nodo.\nLa configuración mínima recomendada para un replica-set consiste en tres nodos: dos serán instancias de MongoDB con acceso a los datos; uno de estos será el nodo primario mientras que el otro replicará las operaciones que se realicen sobre el primario. El tercer nodo se denomina arbitro, solamente se utiliza para decidir que nodo debe ser asignado como primario. En caso de pérdida, el nodo “secundario” pasara a ser el primario ya que ha realizado las réplicas de todas las operaciones del nodo primario.\nLa principal diferencia con Mongodump es que hace una copia de seguridad de los datos conectándose a una instancia de mongod o mongos en ejecución. Esto permite crear una copia de seguridad para un servidor, una base de datos o una colección completa. Se puede ejecutar sin argumentos y esto creará una copia de seguridad en la base de datos de la carpeta dump/ siempre y cuando la carpeta se encuentre en el sistema local.", | |
| "m1_score": 0.75, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 0.5, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "bc0ec2cd7a91c72da74e5d7a4ec67a9e" | |
| }, | |
| "79136144K": { | |
| "respuesta_completa": "El objetivo del replica-set es crear un ambiente donde se de una recuperación automática frente a fallos en el sistema. Se consigue mediante la redundancia de datos. Existe un nodo primario que va replicando sus datos en los nodos secundarios. Esta copia siempre va a estar actualizada. Mediante la replica-set de Mongo se consigue una alta disponibilidad frente a los fallos que puedan ocurrir en el sistema. Otra ventaja es que se balancea la carga automáticamente entre los nodos del replica-set lo que hace que aumente nuestro rendimiento. \nPara una configuración mínimas son necesarios 3 nodos, 1 el primario y 2 secundarios. Respecto a los 2 secundarios uno se llamara secundario y el otro será llama árbitro. El arbitro únicamente decide que nodo tiene que ser empleado como primario. Si el nodo primario falla, uno de esos nodos secundarios será elegido como el nuevo nodo primario.\n\nMongodump también puede hacer una copia de seguridad de los datos y la puede restaurar con mongostore. La principal diferencia es que éste es un proceso manual que tiene que hacer el propio usuario. Sin embargo con la configuraciñon replica-set ya se tiene una recuperación automática frente a los fallos que puedan ocurrir.", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "b5b1b7329e33e1ba1459273adae97e78" | |
| }, | |
| "73133351K": { | |
| "respuesta_completa": "Un replica-set consiste en la replicación de servidores. Se puede implementar en MongoDB y se trata de una refinación del modelo maestro-esclavo. El replica-set permite la redundancia de datos y la alta disponibilidad. Además, sirve como medida anti-caída de un servidor y también para implementar la replicación. \nLa configuración mínima de un replica-set consta de tres nodos: un nodo primario, un nodo secundario y un nodo árbitro. El nodo primario se escoge a la hora de crear el replica-set. \nEn caso de que el nodo primario falle se realiza una votación donde el nodo árbitro se encarga de elegir al nuevo nodo primario. La elección la toma en función del número de votos de cada uno de los nodos secundarios y de sus características, ya que hay nodos que no pueden ser nunca nodo primario, por ejemplo, el nodo árbitro o un nodo que esté oculto. \nMongodump es un comando que se emplea para realizar una copia de seguridad (volcado de datos) de la base de datos tal y como si se tomara una fotografía. Sin embargo, un replica-set permite tener una imagen actualizada en todos los nodos pertenecientes al conjunto sin necesidad de realizar una copia.", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 0.5, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "53ebdb2239cc53c714efaaa26e576c4c" | |
| }, | |
| "31008668E": { | |
| "respuesta_completa": "El método de replica-set permite una recuperación a fallos de forma automática, y es la forma recomendada de implementar una replicación de los datos en MongoDB. \nPara una configuración mínima es necesario 3 nodos, los cuales dos nodos son instancias de mongod con acceso a los datos, uno de estos nodos es el nodo primario y el otro nodo replica las operaciones que se realizan sobre el primario. El tercer nodo es llamado, árbitro, y su única función es decidir qué nodo deber ser asignado como primario. Cuando un nodo primario deja de tener disponibilidad, es cuando actúa el tercer nodo árbitro, que decide quien pasa a ser el nodo primario. \nLa principal diferencia con mongodump, es que esté realiza una copia de seguridad de los datos conectándose a una instancia de mongod o mongos en ejecución, esto permite realizar una copia de seguridad para un servidor o base de datos, o permite utilizar una consulta para copiar solo una parte de la colección", | |
| "m1_score": 0.75, | |
| "m2_score": 0.5, | |
| "m3_score": 0.5, | |
| "m4_score": 0.75, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "40f310f15c326b49d534adb6e15cf073" | |
| }, | |
| "53630942 W": { | |
| "respuesta_completa": "Replicaset es una característica de MongoDB que permite la replicación de los datos para incrementar su disponibilidad permitiendo la recuperación de datos frente a fallos. La arquitectura básica esta conformada por tres nodos (Primario-Secundario-Árbitro), es decir, nodo primario recibe las operaciones de escritura y estas son replicadas al secundario automáticamente, obteniendo así los mismos datos en ambos. La selección de los roles se realiza de manera aleatoria. Sin embargo, el nodo árbitro se utiliza para decidir que nodo debe ser primario en caso de que el primario deje de tener disponibilidad. Por tanto, en caso de fallo del primario asumiría dicho rol el secundario. \nAdicionalmente, MongoDB tiene una funcionalidad “mongodump” que permite respaldar los datos actuales de la BBDD, es decir, realiza una foto fija de la misma y esta es guardada y exportada en archivos para en caso de pérdida poder recuperar la última “foto/copia”. La principal diferencia con el replicaset es que “mongodump” interrumpe el servicio hasta que manualmente volvemos a recuperar la copia realizada, además que con esta funcionalidad podemos perder datos ya que no se replica de manera constante o en “streaming” como si lo hace el replicaset.", | |
| "m1_score": 1.0, | |
| "m2_score": 1.0, | |
| "m3_score": 0.5, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "b987f8fb47ae6497f73ee45146d8b75a" | |
| }, | |
| "22756875P": { | |
| "respuesta_completa": "La función de un replica-set en MongoDB es la de dar respaldo a fallos de forma automática. La configuración mínima para un replica-set, y que por defecto aparece configurado así, es de 3 nodos. Estos 3 nodos están enviándose pings cada dos segundos para conocer si están disponibles (no se han caído).\nLos 3 nodos son los siguientes:\n-\tPrimario: es elegido de forma dinámica. Es el que gestiona las operaciones.\n-\tSecundario: realiza las réplicas de escritura sobre el nodo primario, de esta forma, si se cae el primario, el secundario ocupa su puesto y el sistema sigue funcionando.\n-\tÁrbitro: se ocupa de elegir quien de los dos nodos va a ser el primario.\nLa principal diferencia con mongodump es que mongodump realiza una copia de una base de datos, colección o subcolección que se le indique, almacenando esta en un directorio. El replica-set en cambio funciona como respaldo automático en caso de caída de algún servidor.", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 0.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "56b47fc533b4f14267f5887cb9103b05" | |
| }, | |
| "26500378P": { | |
| "respuesta_completa": "MongoDB proporciona varios mecanismos de respaldo para los datos. Una de ellas es la capacidad de replicación o redundancia de los datos. Para ello, MongoDB utiliza la arquitectura réplica-set, que es un refinamiento de la arquitectura maestro servidor. \nEn replica-set, un nodo primario, o maestro, es elegido por el resto de los nodos en base a la disponibilidad de este. Un conjunto replica-set está compuesto, en su configuración mínima por tres nodos: dos de ellos serán el primario y el secundario, nodo en el que se realiza la replicación de las operaciones sobre el nodo primario. El tercer nodo, llamado arbitrario, se encargará de decidir quién será el nodo primario, en caso de empate en la votación. La votación se llevará a cabo si el nodo primario deja de estar disponible. Para comprobar el estado del sistema, los nodos se hacen ping entre ellos cada 2 segundos.\nLa diferencia de este método de replicación respecto a mongodump, es que mongodump crea una copia de seguridad que puede restaurarse en otro mongo utilizando mongorestore. Replica-set proporciona una replicación completa de un nodo primario para poder sustituirse inmediatamente en caso de que deje de estar disponible.", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "624a61346ee721323b887af8fed7eac7" | |
| }, | |
| "77839987-Y": { | |
| "respuesta_completa": "Un Replica-Set, como su nombre indica, es un sistema de replicación específico de MongoDB. Se basa en la arquitectura Maestro-Esclavo. Esto es, las escrituras son recibidas por un nodo Primario (Maestro) y este se encarga de comunicar su estado mediante un heartbeat a los Secundario (Esclavos), que se actualizan (con un intervalo de tiempo) al encontrar cambios. \nSe caracteriza porque el nodo Primario no es estático, se escoge mediante una votación interna. Aunque se pueden configurar prioridades dentro de cada nodo, de manera predeterminada cualquier nodo puede ser Primario. De este modo, si se pierde la disponibilidad del primario, se sigue manteniendo el sistema, sin tener que restablecer nada. \nEn este sistema la configuración mínima es de 3 nodos, un Primario, un Secundario y un nodo Árbitro. Que no será Primario nunca, solo se encarga de mantener la conexión y aportar su voto en la elección del Maestro. ", | |
| "m1_score": 0.75, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 0.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "375c9f81952e5da9fc1e5f5bf9fcf0bb" | |
| }, | |
| "X3109431S": { | |
| "respuesta_completa": "La función de un replica-set es la distribución de los datos en diferentes servidores para los cuáles existen tres nodos para una configuración mínima. Habrá dos nodos de almacenamiento, de los cuáles uno será el primario y otro el de replicación. El primario recibe las consultas y replica las operaciones al nodo de replicación. El tercer nodo será el que recibe el nombre de árbitro y decide qué nodo debe actuar como primario o como replicación. Si el nodo primario deja de tener disponibilidad, el nodo de replicación ocupará su lugar. Además, la comunicación entre los nodos se lleva a cabo través de pings (avisos) cada 2 segundos para confirmar que todos ellos siguen activos.\nMongodump permite exportar la base de datos, colección o parte de la base de datos a otro servidor, pero no garantiza la disponibilidad en paralelo además de que no tiene por qué tener la base de datos completa en otro servidor mientras que el replica-set consiste precisamente en poder recuperar la base de datos completa", | |
| "m1_score": 0.5, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 0.75, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "403a05fd0bcd4addf67ce479533c4159" | |
| }, | |
| "49125521M": { | |
| "respuesta_completa": "Un replica-set (conjunto de réplicas) es un mecanismo mediante el cuál permite la redundancia y el incremento de la disponibilidad de los datos. Además, permite una recuperación a fallos de forma automática, y es una de las formas más recomendadas de implementar replicación de datos en MongoDB.\nEste consiste en tener un nodo primario que replica sus datos a los nodos secundarios, manteniendo así una copia actualizada de dichos datos. Para la configuración mínima de un replica-set es necesario tres nodos, uno primario y dos secundarios, los cuáles se van actualizando. En el caso de que el nodo primario dejara de tener disponibilidad, automáticamente se elije uno de los nodos secundarios, siempre que no tenga “priority: 0” (este no podrá ser nunca nodo primario, es conocido como árbitro y solo interviene en la elección del nodo primario).\nPor otro lado, existe una herramienta en MongoDB que permite realizar copias de seguridad de las bases de datos, esta es mongodump, y se restaura con mongorestore; pero esto es un proceso manual y no de manera automática como la recuperación del replica-set", | |
| "m1_score": 1.0, | |
| "m2_score": 1.0, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "e364b8a8d0183da2d9676d8907b95e55" | |
| }, | |
| "25605969T": { | |
| "respuesta_completa": "La función de un replica-set es dar respaldo a los datos. Un replica-set es una estructura que se crea para que en caso de error en el nodo primario no perdamos toda la información. \nPara crear un replica set son necesarios 3 nodos, el nodo primario, el nodo secundario y el arbitro. \nLa función que tienen estos nodos es: \n- nodo primario: guardar la información. \n- nodo secundario: hacer una copia de esta información y mantenerla hasta que sea necesario, que por caída del nodo primario se ponga en funcionamiento. \n- arbitro: encargado de nombrar al nodo secundario que comienza a actuar en caso de que el primario deje de tener disponibilidad. \nMongodump es un buen método de respaldo de la información, pero realiza la copia de seguridad en un momento dado, a diferencia de replica- set que se mantiene actualizada. ", | |
| "m1_score": 0.0, | |
| "m2_score": 0.0, | |
| "m3_score": 0.0, | |
| "m4_score": 0.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "cc74af2802f44d4dd32ff43c7035e086" | |
| }, | |
| "20904222M": { | |
| "respuesta_completa": "MongoDB nos ofrece una forma de mantener seguros nuestros datos mediante la redundancia de los mismos, ofreciendo alta disponibilidad sobre ellos. \nMongoDB ha realizado un refinamiento sobre el sistema Maestro-Esclavo, en el cual el nodo maestro recibe y ejecuta las instrucciones y el esclavo las repite.\nUn replicaset consta debe constar de un mínimo de tres nodos: el primario (recibe y ejecuta las instrucciones), el secundario (repite lo que haga el primario) y el árbitro (en caso de que falle el primario, vota para cual debe sustituirle). \nEntre los nodos primario, secundario y árbitro, se envían “pings” o avisos para comprobar que todos continúan conectados.\nEn el caso de que existan más nodos secundarios, y se cayese el primario, todos los secundarios pueden votar para elegir cual se convierte en primario, pero no todos los secundarios pueden convertirse en primarios. El árbitro sirve en caso de que exista un empate.\nLa diferencia con mongodump radica en que mongodump realiza una copia de los datos, pero no existe esta arquitectura en línea para comprobar todos los pasos que realiza el primario y la comprobación de qué nodos se encuentran activos. Sin embargo, ambos son formas de garantizar la seguridad de los datos.", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "9086ffc9bd11901abadbe95477d2292c" | |
| }, | |
| "02720025E": { | |
| "respuesta_completa": "La arquitectura replica set es una evolución del sistema de Replicación de archivos Maestro-Esclavo. Con la arquitectura replica-set somos capaces de tener toda la información en tiempo real duplicada en diferentes nodos.\nUna correcta arquitectura de replica-set debe contar con mínimo tres nodos que se comunican cada dos segundos: árbitro (que no almacena datos sino que decide qué otro nodo es el primario), primario (principal fuente de acceso a los datos) y secundario (que replica todo lo que hace el nodo primario).\nMongodump, sin embargo, se usa para crear una copia de seguridad de una instancia en ejecución según la necesidad (colecciones completas, base de datos…) en un momento de tiempo determinado.", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 0.5, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "1c349c3eb06025e5ccc0a215cc9ad35f" | |
| }, | |
| "54172161P": { | |
| "respuesta_completa": "Un replica-set es un mecanismo de respaldo de MongoDB que consiste en interconectar un conjunto de nodos o servidores siguiendo el modelo maestro-esclavo. De este conjunto de nodos o servidores interconectados (al menos dos), uno de ellos es elegido nodo primario y, a parte de ese, debe haber, al menos, un nodo secundario. El nodo primario será el que responda ante operaciones CRUD realizadas por las aplicaciones cliente y deberá propagar las modificaciones de los datos a los nodos secundarios, de modo que cada uno de ellos tenga siempre una imagen actualizada de los datos. Este mecanismo aporta alta disponibilidad, consistencia y robustez frente a fallos en los servidores. En caso de que el nodo primario caiga, uno de los secundarios disponibles será elegido primario en una votación, siendo elegido este cuando consiga mayoría absoluta. Para las votaciones existe un tipo de nodo especial: el nodo árbitro. Este tiene el único papel de decidir en las votaciones. Además de este existen otros nodos especiales, como son el nodo retrasado (tiene una imagen retrasada del conjunto de datos), nodo de prioridad 0 (este nunca puede ser presidente), nodo oculto (no aparece visible para los usuarios), etc. \n\nExiste otro mecanismo de respaldo llamado mongodump, el cual realiza una fotografía de un momento concreto de todas las bases de datos, de algunas bases de datos o algunas colecciones dentro de una base de datos, según como indique el usuario. En caso de pérdida o daño en los datos, se podría hacer una restauración con el comando mongorestore según la fotografía de los datos en el momento que se hizo. \n\nLa diferencia fundamental entre los replicasets y mongodump es que mientras los replicaset realizan copias continuas y automáticas de los datos del nodo principal en otros nodos (copias actualizadas), mongodump es una copia de un momento concreto (no actualizada).", | |
| "m1_score": 1.0, | |
| "m2_score": 1.0, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "653e6dc27f1031bcd8e1c1fa62070649" | |
| }, | |
| "02224902_20210320213352": { | |
| "respuesta_completa": "Una arquitectura replica-set es una alternativa muy recomendada que ofrece MongoDB para respaldar las bases de datos en caso de fallo o caída de un servidor, ofreciendo alta disponibilidad de los datos y recuperación a fallos de forma automática. La arquitectura mínima de un replica-set es:\n•\t2 nodos con los que podremos acceder a los datos. Uno será el principal con el que podremos trabajar y el segundo será el secundario que replicará las acciones que realicemos.\n•\tEl tercer nodo deberemos configurarlo en su creación, denominado arbitrario. Solo decide que nodo es asignado como primario y se comunica con los otros 2 cada cierto intervalo de tiempo. \nEn caso de fallo del nodo principal, el replica-set detecta la desconexión, cambiando al secundario a realizar de principal. Automáticamente, tenemos acceso a las bases de datos pudiendo trabajar con el nuevo principal. Si se reconectara el nodo caído este pasaría a ser el secundario replicando al principal. \nLa principal diferencia de un Replica-set con otra alternativa de respaldo como Mongodump (exportación de bases de datos a un fichero) es que automatizamos la recuperación porque con el otro método deberíamos importar los datos manualmente. Además, podríamos sufrir una pérdida de datos dependiendo de cuando se realizo la exportación. ", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "8eaadfcb8902c35bc11e5ae1c8639892" | |
| }, | |
| "75923577W": { | |
| "respuesta_completa": "La arquitectura ‘Replica-Set’ de MongoDB hace alusión a una de las configuraciones estructurales de respaldo que ofrece esta base de datos NoSQL, la cuál hace permite asegurar en un mayor grado la disponibilidad de los datos. \nDicha configuración está basada en la definición de tres tipos de nodos en su sistema de almacenamiento distribuido, cada uno con una función propia dentro de la tarea de respaldo y que son los siguientes:\n-\tNodo principal: constituye el ‘datanode’ de almacenamiento principal, es decir, es en éste donde se leen y escriben directamente los datos.\n-\tNodo secundario: hace la función ‘datanode’ de respaldo del nodo principal, es decir, recibe la información generada por el nodo principal con el retraso/’delay’ establecido por el intervalo de ‘Pings’ enviados entre los mismos.\n-\tNodo árbitro: se limita únicamente de administrar y votar/asignar el papel (principal, secundario) de los nodos de tal manera que se garantice la mayor disponibilidad posible.\nEsta configuración de respaldo requiere por tanto de un mínimo de 3 nodos para su funcionamiento en producción, siendo posible la configuración de muchos más por supuesto, gracias a escalabilidad horizontal que ofrece la base de datos MongoDB. Podríamos sumar más máquinas/nodos que nos permitan cumplir con el factor de replicación (nº de nodos de respaldo) que se requiera.\nEn el caso que uno de los nodos elegidos como principal, se caía/pierda disponibilidad el nodo árbitro actúa nombrando un nuevo nodo principal (normalmente según el índice de probabilidad del resto de nodos para ser elegidos como principal ‘votes’) y considerando que el nodo secundario del principal ‘caído’, dispone del respaldo y metadatos generados por el mismo.\nLa principal diferencia que separa esta configuración de réplicas a la funcionalidad ofrecida por ‘mongodump’, es el dinamismo que ofrece, al disponer de un coordinador/’árbitro’ dentro del propio sistema de almacenamiento distribuido, que además está configurado para que tome un comportamiento de preventivo y reactivo, en caso de fallo de los nodos, para el aseguramiento de la disponibilidad de la base de datos, pudiendo ‘reestablecerse de manera ágil’ (cuestión de segundos). Mientras que ‘mongodump’ es una alternativa de respaldo mucho más cercana a las copias de directorio convencionales, ya que se base en la copia de todos o parte de los datos en directorio externos, algo que ofrece seguridad frente a la recuperación, pero no agilidad en caso de necesidad de restauración, ya que en este caso, necesitaría hacer uso de ‘mongorestore’ para recuperar el respaldo generado por ‘mongodump’ en la ubicación concreta.", | |
| "m1_score": 0.5, | |
| "m2_score": 0.25, | |
| "m3_score": 0.25, | |
| "m4_score": 0.5, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "761c1c9b8459ec1b129a8d9b5d587f57" | |
| }, | |
| "80098232L": { | |
| "respuesta_completa": "Un replicaset consiste en un sistema de respaldo de mongoDB, que basado en un modelo Maestro-Esclavo refinado cuya función es evitar la caída del sistema por fallo en la máquina donde corre el DBMS. Está compuesto de, al menos, de 3 réplicas que interactúan entre ellas cada 3 segundos mediante ‘pings’ (un replicaset será primario, otro secundario y el tercero o árbitro tan solo sirve para votar cuál de ellos será el primario (el árbitro no puede ser primario)). Los nodos votan al primario y el que gana la votación ejercerá como tal hasta el momento en el que se detecte que este se ha caído. En ese caso, el nodo secundario pasará a ser primario y el antiguo primario, cuando vuelva a estar operativo, entrará como secundario. Lo importante de este proceso es que toda la información (datos, actualizaciones, etc) que le llegaba al primario, la recibía también el nodo secundario, de forma que en pocos segundos se recuperaría el proceso. \nEn el caso del replicaset el problema se resuelve de manera instantánea, mientras que con las funciones mongodump y mongorestore es totalmente manual y hay que prever la situación realizando copias previamente", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 0.5, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "c7daf68382ba769cc135ad1301141fb8" | |
| }, | |
| "48234395Z": { | |
| "respuesta_completa": "Replica-set es un método de replicación utilizado por MongoDB para dar respaldo a los datos de la BBDD. Se trata de un método de redundancia de datos para dar respaldo y aumentar la disponibilidad de los mismos y poder seguir trabajando pese a que uno de los nodos se caiga. Además, mejora el rendimiento puesto que solo es necesario escribir en el nodo principal, pero podemos leer de cualquiera de los nodos. Para una configuración mínima es necesario tener mínimo 3 nodos, 1 primario y el resto secundarios.\nSi el nodo primario cae y deja de tener disponibilidad el resto de nodos se dan cuenta gracias al heartbeat que se envían cada 3 segundos y en ese momento serán los secundarios los que decidirán mediante votación cuál de ellos pasa a ser el nuevo nodo principal.\nEl método de copia de seguridad mongodump solo sirve para hacer una copia de una foto fija a la BBDD si se hacen modificaciones posteriores al restaurar la BBDD se habrán perdido mientras que con un replica-set los demás nodos están constantemente actualizados. Por el contrario, si borramos un elemento y futuramente queremos recuperarlo con replica-set no podremos mientras que con mongodump lo recuperariamos", | |
| "m1_score": 1.0, | |
| "m2_score": 1.0, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "2fb405439e8aaae1d342716e1b595d83" | |
| }, | |
| "45574617W": { | |
| "respuesta_completa": "La arquitectura de Réplica-Set en MongoDB permite la redundancia de datos e incrementa la disponibilidad de los datos. Es una mejora sobre el modelo de Maestro-Esclavo, y es lo que ha definido como conjunto réplica -set. Con este método se permite recuperar de forma automática una recuperación a fallos.\nUna característica de los replica set es que no definen un nodo maestro estático, es asignado al azar y esta asignación se actualiza en función de la disponibilidad de los nodos. Los nodos mantienen el control unos sobre otros. Para crear un conjunto réplica set es necesario tener tres nodos (configuración mínima recomendable) de los cuáles dos nodos serán instancias de mongod con acceso a los datos; uno de estos será el nodo primario y el otro replicará las operaciones. El tercer nodo es el llamado nodo arbitrario y se utiliza para decidir qué nodo deber asignado como principal.\nCuando el nodo primario deja de tener disponibilidad el nodo secundario pasa a ser el principal ya que tenemos la figura del nodo arbitrario.\nLa principal diferencia con mongodump es que es un proceso automático, sin tener que realizar las operaciones de movimiento de las copias de seguridad. ", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 0.5, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "d1bff6709d7728e5a45af677ae0b75c1" | |
| }, | |
| "48091233G": { | |
| "respuesta_completa": "Replica-set en mongoDB se basa en un mecanismo de recuperación automática frente a fallos mediante la redundancia de los datos. Dicho mecanismo se basa en tener un nodo primario que va replicando los datos a los nodos secundarios, los cuáles en todo momento mantendrán una copia actualizada de todos los datos. En caso de fallo del nodo primario, alguno de los secundarios es elegido como nuevo nodo primario. Este mecanismo permite una alta redundancia de los datos y una alta disponibilidad, una arquitectura replica-set nos brinda la ventaja de balancear la carga automáticamente entre los nodos del replica-set. \nPara una configuración adecuada se requieren mínimo 3 nodos: 1 nodo primario, uno secundario y un árbitro. \nMongoDB también dispone de “mongodump” para replicarl os datos y “mongorestore” para restaurarlos", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 0.5, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "6c474f1ce11f4c3c4afb5c683a46754c" | |
| }, | |
| "49224226V": { | |
| "respuesta_completa": "La función de un replica-set es ofrecer garantías frente a la posibilidad de caída de un nodo, son necesarios mínimo tres nodos para realizar un despliegue de mongo con replica-set. Cuando un nodo primario cae, los nodos secundarios votan un nuevo nodo primario. Mongodump se realiza una vez y no se actualiza automáticamente, mientras que un replica-set se configura con un tiempo determinado tras el cual realiza las mismas operaciones que el nodo primario.", | |
| "m1_score": 0.25, | |
| "m2_score": 1.0, | |
| "m3_score": 1.0, | |
| "m4_score": 0.5, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "197202cada30464d0dccd61b6d0ba4db" | |
| }, | |
| "77386633M": { | |
| "respuesta_completa": "Una Replica-Set en MongoDB es una arquitectura en la que se garantiza la alta disponibilidad de los datos y protección frente a fallos. \nPara configurar un Replica-Set en MongoDB hacen falta mínimo 3 nodos. Uno primario, otro secundario que realiza las mismas operaciones que el primerio y un nodo árbitro que decide quién es el primario.\nSi un nodo primario se cae cuando el nodo árbitro se dé cuenta, le comunicará a un nodo secundario que debe pasar a ser primario. El tiempo en el que esto ocurra depende de la frecuencia con la que se haya configurado la comunicación entre los nodos, que por defecto es 2 segundos.\nSu principal diferencia con mongodump es que mongodump realiza una copia de la base de datos cuando lo ejecutamos, mientras que Replica-Set va copiando en los nodos todos los cambios que vayamos realizando en la base de datos", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "b03dbc813da7be54a82dfe329a859b44" | |
| }, | |
| "72834193R": { | |
| "respuesta_completa": "El Replica-Set de MongoDB es una medida de respaldo que permite tener los datos duplicados en varios nodos. Además, es un refinamiento del modelo Maestro-Esclavo, con la diferencia principal de que no existe un nodo maestro estático como tal. La configuración mínima de esta arquitectura contendrá tres nodos (uno se asignará como primario de manera aleatoria, uno de los secundarios replicará las modificaciones realizadas y el ultimo nodo será el árbitro). Una de las funciones principales de esta arquitectura es la alta disponibilidad de los datos, ya que si un nodo primario deja de tener disponibilidad se elige un nuevo nodo primario mediante una votación. Esta disponibilidad se obtiene mediante el envió de ping entre nodos que se realiza cada dos segundos. Además, se consigue mantener una consistencia entre los nodos y existe un balanceo de carga (las escrituras solo se realizan en el nodo primario). Mongodump realiza una foto o instantánea de la base de datos, mientras que en un conjunto replica-set cualquier modificación de los datos se replica en los demás nodos. De esta manera, se dispone de la información de la base de dato totalmente actualizada en el caso de que algún nodo deje de estar disponible. ", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "915ceea06887d6f09ba9b6428e304511" | |
| }, | |
| "44645938V": { | |
| "respuesta_completa": "Replica set se trata de una arquitectura de sistemas pensada para MongoDb que tiene como fin mejorar el rendimiento y robustez del sistema, convirtiéndose en un sistema de alta disponibilidad. Se basa en un sistema maestro esclavo donde un nodo maestro va comunicando los cambios a su conjunto de nodos esclavos, manteniendo varias instancias actualizadas al mismo tiempo y pudiendo leer los datos de cualquiera de ellas, lo que nos permite un balanceo de carga (las escrituras se realizan a través del maestro). En caso de fallo del maestro, el resto de nodos elegirían un nuevo maestro mediante un sistema de votos.\nEn cuanto a las diferentes configuraciones la mínima sería aquella en la que existe un único nodo maestro y un nodo esclavo, mientras que la más típica sería un maestro, un esclavo y un árbitro, este último únicamente tiene la función de participar en la votación de un nuevo nodo maestro en caso de caída del sistema, es decir no contiene datos.\nLa diferencia con mongodump es que mientras este crea copias de seguridad y las restaura en caso de fallo (perdiendo los datos desde la última copia), replica-set se levanta en unos minutos con la información actualizada.", | |
| "m1_score": 1.0, | |
| "m2_score": 1.0, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "64128cc76e7db51256e042661fff77cb" | |
| }, | |
| "47921622H": { | |
| "respuesta_completa": "La arquitectura replica-set es un refinamiento de MongoDB del modelo Maestro-Esclavo, en el que una instancia maestra recibe las operaciones y las replica en la instancia esclava. Este modelo permite que haya respaldo de los datos, es decir, que existan copias de restauración que se actualicen dinámicamente según ocurren las operaciones para poder recuperar los datos en caso de fallo.\nEn el caso del replica-set, la configuración mínima es de tres instancias: una primaria, una secundaria y una árbitro. La primaria recibirá las operaciones y las transmitirá al resto de instancias secundarias. El nodo árbitro sólo tendrá poderes de voto (no almacena datos) para elegir un nuevo primario en caso de que el actual falle. Es decir, ante fallo de la instancia principal, una de las secundarias (sin retraso en la actualización y no oculta) tomará el rol de primaria tras unas elecciones.\nEl punto fuerte de esta configuración es que la copia de seguridad se actualiza en el secundario según ocurren las operaciones, mientras que otros métodos de respaldo como el comando mongodump sólo generan una copia de seguridad puntual, es decir, con los datos que haya en el momento de correr el comando", | |
| "m1_score": 1.0, | |
| "m2_score": 1.0, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "4f0da78d71f8c741ac8add282a1d1a77" | |
| }, | |
| "77394225F": { | |
| "respuesta_completa": "La replicación es una técnica de respaldo que consiste en realizar una copia de los datos en varios nodos (servidores) cada vez que se realiza una escritura en el nodo primario. Esta copia se efectúa de forma automática, no de forma manual como en el volcado de datos (dump). \nUn réplica set ofrece respaldo (ante una caída del nodo primario se tiene una copia de los datos), disponibilidad (ante una caída del nodo primario, un secundario pasará a primario) y balanceo de carga (la escritura se realiza en el nodo primario y la lectura en el primario o secundario/s).\nLa configuración mínima de un réplica set consta de:\n- 1 nodo primario, donde se pueden realizar operaciones de escritura y lectura.\n- 1 nodo secundario, donde solo se pueden leer datos.\n- 1 nodo árbitro, el cual establece con su voto de desempate qué nodo secundario debe pasar a primario ante una caída del nodo primario.\nEn caso de caída del servidor primario, los nodos secundarios lanzan un voto para determinar qué nodo debe ser primario. El nodo secundario con más votos pasará a primario, y el antiguo nodo primario cuando se reincorpore lo hará como secundario.", | |
| "m1_score": 1.0, | |
| "m2_score": 0.5, | |
| "m3_score": 1.0, | |
| "m4_score": 1.0, | |
| "resp_m1": "", | |
| "resp_m2": "", | |
| "resp_m3": "", | |
| "resp_m4": "", | |
| "hashed_id": "2a6cb06588a72b29abded5a54d4991c6" | |
| } | |
| }] |