Desde hace aproximadamente 6 años tenía la idea de poder brindar algún tipo de alimento a habitantes de calle en Navidad, en ese entonces me imaginaba cerca de la calle 13 con carrera 10 en Bogotá pudiendo compartir con estas personas un vaso de agua de panela caliente con un pan, como eran mis desayunos hace muchos años. Celebrar la llegada de media noche de este modo, muy lejos de casa, compartiendo con desconocidos alegría y felicidad con una bebida caliente.

Sin embargo, nunca tuve la iniciativa, valentía o decisión de hacerlo realidad, por disponibilidad de tiempo, excusas, miedo o la simple decisión de no hacerlo manteniéndome en la zona de confort en la que siempre había estado con este tema, siempre estuve en la misma pecera con el tema y nunca intenté tomar acción para que esto fuera posible.

No suelo ser una persona que suela compartir dinero con los habitantes de calle o personas que solicitan ayuda en el transporte público, negocios o lugares donde me pueda encontrar; sin embargo, ha ocurrido que cuando estoy comiendo algo y una de estas personas se acerca para pedir ayuda, he compartido de mis alimentos con ellos, ya que este tipo de sensación (hambre) es algo que es realmente genera desesperación, ansiedad, temor y en ocasiones hasta violencia. Las veces que he compartido mis alimentos con estas personas que piden ayuda se van con alegría o felicidad y una inmensa gratitud, y las personas con quienes he estado en ese momento comiendo transmiten desde su rostro una sensación de tranquilidad, compasión y alegría.

Es por esto que este año tomé la decisión de llevar mi vida a otro nivel más alto, con este sueño que había pospuesto desde años atrás, generando valor para nosotros, generando otra vista de la vida como suele ser comúnmente, que seguramente ayudará a llegar a niveles de prosperidad mucho más altos, para lo que me propuse trabajar en un sueño totalmente irracional, cuando tomé la determinación no tenía idea de como hacerlo, qué requería para alcanzarlo, y si iba a ser posible lograrlo. Solo tenía la convicción de alcanzar la meta propuesta, como lo he realizado en muchas otras cosas de mi vida, la tecnología me ha permitido poder cruzar muchas fronteras, tener cosas que nunca me había imaginado, que generan una mejor calidad de vida, así que bueno, sería otro reto más al cual generar frente para hacerlo posible.

Afortunadamente, la vida me ha llenado siempre de personas maravillosas, grupos, nichos y empresas que siempre han creído en mí y mis iniciativas (hasta a ciegas podría decirlo), el reto inicial se planteó para poder impactar 100 personas, y sabía en ese momento que por la confianza, respeto y cercanía de algún modo podrían hacer que este sueño e iniciativa fuera posible, para esto gestioné todo lo que fue requerido y necesario, para poder hacer esto posible. Aquí fue donde mi sentido de hacerlo posible y aterrizar la idea como objetivo era: Brindar a todas las personas a impactar un desayuno como si fuera para mí, para esto se gestionaron todos los recursos necesarios para comprar los elementos para generar la entrega de:

• Chocolate de 12 Onzas clavos clavos y canela
• Pan árabe con finas hiervas
• Tamal super especial

Este desayuno no tiene nada que envidiarle a los que puedan ofrecer en los restaurantes más exclusivos, lujosos y costosos de la ciudad en las cadenas de restaurantes más exigentes. Cuando el sol comienza a desperezarse, se despliega un chocolate espumoso, con aroma a clavos y canela caliente, se convierte en el protagonista de este festín. Su textura suave y su sabor profundo, evocan recuerdos de días pasados, de momentos compartidos en torno a la mesa familiar. Cada sorbo es un abrazo cálido que despierta los sentidos y envuelve el espíritu en una danza de sabores. Acompañando esta delicia, un compañero fiel que nunca puede faltar. Su tamaño generoso invita a ser tomado con ambas manos, mientras que para adornar su sabor incluye hiervas que susurran secretos de la tierra. Su consumo es un ritual; al romperlo, se libera un aroma que evoca mercados lejanos y encuentros con culturas diversas. Este pan no es solo alimento; es un puente que conecta historias y tradiciones, un símbolo de unión y hospitalidad. Y en el centro de esta celebración matutina, se encuentra el mejor tamal, una joya culinaria que lleva consigo la esencia del tolima. Cada bocado es un viaje a través de paisajes vibrantes y sonrisas sinceras. La masa suave y el relleno sabroso se entrelazan en una sinfonía de texturas y sabores, recordándonos la riqueza de nuestras raíces y la importancia de celebrar lo cotidiano, acompañado de una pieza completa de pollo y el toque especial de pimienta para darle el picor exacto. Este desayuno es más que una simple comida; es una experiencia sensorial que despierta los sentidos y alimenta el alma. En cada elemento hay una historia por contar, una conexión profunda con la tierra y con quienes nos rodean. Así, mientras se disfruta de este festín matutino, me doy cuenta de que cada sabor es un verso en un poema sin fin, donde la comida se convierte en arte y la mesa en un escenario donde la vida se celebra con alegría y gratitud.

Un desayuno con el que con solo verlo se te haría agua la boca con el que seguramente esperarías el siguiente alimento ya en la noche, así que se realizaron todas las gestiones necesarias para hacerlo realidad y se eligió el día 22 de Diciembre de 2024 para buscar en el centro de la ciudad a los habitantes de calle que seguramente no han tenido la oportunidad de haber podido saciar la sensación de hambre desde no se sabe cuantas horas o días atrás ni haber podido probar tremendo manjar, se conoce que muchas de estas personas para poder sobrevivir han tenido que incluso buscar sobras de alimentos en la basura o de muy baja calidad. Así que íbamos a cambiar esta situación para estas personas en este día.

Como buen colombiano, ingeniero industrial y característica de análisis que tengo, hice las gestiones necesarias para hacer alcanzar los recursos, para poder cubrir 20 alimentos más, para con esto poder llegar más allá del objetivo propuesto es decir se entregarían 120 desayunos, en este momento nació otra gran alegría y era poder cubrir una mayor cantidad de bocas para su desayuno en este día. Para esto obtuve el apoyo de personas muy cercanas a mi círculo de vida, a quienes realmente estoy totalmente agradecido, quienes hicieron todo lo necesario y posible a su alcance para hacer esto realidad, de todo este grupo de personas recibimos todo el apoyo y amor disponible.

1. Angie Lizarazo
2. Denis López
3. Johana Bautista
4. Carlos Lizarazo
5. Alejandrina Mora
6. Mauricio Grizales
7. Kirsch Cobric
8. Andrea Páez
9. Julián Mora 
10. Jacqueline Velasquez
11. Diego Mariño
12. Wilson Piedrahíta
13. Arianna Almenar
14. Ana Oviedo
15. Eliana Rodríguez
16. Sofía Rodríguez
17. Andrea Cortés
18. Lluvia Pinzón

Quise compartir con estas personas la posibilidad de tener esta experiencia y que la vivieran totalmente, ya que seguramente se les pasó por algún momento de la cabeza hacerlo posible, y no tenían los medios para hacerlo o haber planeado de alguna manera hacerlo realidad. La verdad solo esperaba contar con 10 personas, pero aquí se refleja la abundancia, llegó mucho mas apoyo del que esperaba.

Cuando lo entregas todo, los sueños se hacen realidad 😊

Finalmente el día había llegado, la ansiedad y felicidad no me daba, ya que sabía que en contadas horas todo debía ya materializarse, desde las 4AM del día 22 de diciembre de 2024 se iniciaron las tareas de alistamiento, empaque y desplazamiento hacia el centro de la ciudad, allí nos encontramos con las personas que quisieron brindar de su tiempo, disponibilidad y amor para compartir con estas personas y simplemente dejamos que todo pasara, se realizó la entrega de estos SUPER DESAYUNOS donde en respuesta de las personas a quienes se les brindó los alimentos recibimos de ellas:

• Agradecimientos infinitos
• Sonrisas
• Oraciones
• Historias
• Gratitud
• Sinceridad
• Cariño

Estuvimos realizando la entrega iniciando en el sector de Las aguas, sin embargo, conforme transcurría el tiempo, los habitantes de calle desaparecían, ya que estos eran movidos por las personas de seguridad o policía hacia la carrera 10 o la carrera 14, porque esta normalmente es una zona de turismo (y más un domingo) y no permitían que siguieran allí, evaluamos la decisión, pero ir a esta otra zona podría ser complicado, por lo que tomamos la determinación de desplazarnos luego hacia la Plaza de Bolívar, donde normalmente suelen verse personas en esta situación, y nos encontramos con la sorpresa de que tampoco estaban por allí, encontramos muy pocas personas, aquí entró un poco la incertidumbre de poder saber qué ocurría con ellos y conocer donde podrían estar concentrados.

Así que tomamos un nuevo rumbo y nos desplazamos posteriormente hacia el sector del Bronx Distrito Creativo o la Iglesia el Voto Nacional esta zona fue la más dura de toda, encontramos personas durmiendo entre bolsas de basura (ellas dentro, para protegerse del frío, viento y lluvia), otras entre chasis de vehículos abandonados, o simplemente acostadas en el piso en forma de caracol o en posición fetal. También tuvimos acercamientos en la Plaza España, el plan de distribución se realizó en cuatro grupos donde cada uno llevaba alimentos para hasta 5 personas, donde se les entregó a cada persona su desayuno con el objetivo de realizar la mínima utilización de elementos plásticos.

Estos son algunos de los mensajes que ha dejado la actividad entre quienes participaron.

Me lleno saber lo agradecidos que son los habitantes de calle con este tipo de actividades y que aunque ya hayan comido, prefieren darle la oportunidad a otros, incluso llamándoles para que asistan.

Saber que aunque en sus condiciones menos favorables se ayudan y apoyan entre ellos.

Ana Oviedo

Me llena saber que podemos servir a los demás, y poder dar un poquito de alegría a las personas que lo necesita, hacemos esto de corazón porque es mejor dar que recibir.

La alegría de sus rostros y el agradecimiento llenan mi corazón de satisfacción y me ayudan a ser mejor persona, y ver qué si queremos podemos ser empáticos con aquellos que no tienen nada.

Andrea Páez

Como sociedad tenemos muy olvidados a los habitantes de calle. Se necesitan más iniciativas como la de Jhosman, para llevarles comida y una sonrisa

Diego Mariño

Los habitantes de calle son personas muy honestas, fue una actividad bonita y me llenó bastante el corazón poder ir a llevarles desayunos.

Arianna Almenar

El impacto social al ver como un tamal podría llegar a ser el lujo más grande para alguien teniendo en cuenta que yo puedo acceder a un tamal en cualquier momento y pues eso duele un poco saber eso.
Me llenó haber visto esas caras esas gracias y esos gestos de felicidad en un persona que vive en una lucha pensada día tras día

Julian Mora

Me pareció muy bonita la experiencia, es muy gratificante este tipo de actividades, se siente muy bien poderle dar a estas personas poderles brindar algo que para nosotros es muy normal, para ellos no es muy fácil de conseguir.

Joana Bautista

Fue una actividad de solidaridad y de compartir, esto es muy en riquedecor, recordar que no todos tenemos las mismas pruebas en la vida y con esto nos damos cuenta que no por eso alguie deja ser menos que otros, hay retos que otros, y hay circunstnacias que son mas exigentes, admiro a todas esas personas que aún siguen de pie a pesar de todas las adversidades sin juzar la manera en la que lo haga, pienso que la experiencia humana es diferntes para todos, en la manera que cada quien tiene sus propios propósitos, a veces pienso que las personas que están en situación de calle, se han puesto propósitos muy grandes, por que no debe ser muy fácil en esta situación, y por esto no los siento menos que los demás, espero puedan resolver si situación.

Krisch Cobric

Varias de las personas a quienes se les entregó el desayuno me dijeron «Este es el mejor desayuno que me he comido en mucho tiempo, muchas gracias, está super delicioso» en realidad la sensación de poder haber hecho realidad este sueño y al haber terminado escuchar «lo lograste» acompañado por aplausos y abrazos la verdad no tiene precio, para mi es muy gratificante haber tenido el apoyo de todas y cada una de las personas que estuvieron ahí con el compromiso, dedicación y amor, por permitirse salir de su zona de confort y vivir esta experiencia. Lo que quería compartir con todos era justamente un desayuno como yo me lo esperaría cualquier día del año, el mejor desayuno del mundo.

Jhosman Lizarazo

Al finalizar toda la actividad, algunas de las personas por sus actividades diarias o planeadas tuvieron que retirarse del grupo; sin embargo, esto no quitó valor ni compromiso, a quienes agradezco enormemente por su disponibilidad y disposición, quienes a pesar de tener compromisos ya planeados para este día pudieron brindar algo de su tiempo para hacer este sueño realidad, tengo total gratitud con las personas que pudieron estar en esta actividad que no tenía otra finalidad que ¡cumplir sueños! estoy convencido que esta vivencia hará que quienes apoyaron y ayudaron a que todo esto hubiera sido posible llevarán su vida pronto a otro nivel mas alto.

Varios me preguntaban: pero y como hizo, de donde salió el dinero, los recursos, alguien lo donó o todo esto salió de su bolsillo, la respuesta es simple: Si los sueños se quieren cumplir solo se hacen realidad, no importa qué, solo debes hacerlo posible sin importar las adversidades, ni cuanto cueste, ni todas las maromas que se deben realizar para hacerlo realidad. 💫

Ya finalizando el medio día nos quedaba la última unidad y decidimos estar de regreso hacia casa con la ilusión de que seguramente encontraríamos a otra persona en la misma situación de calle en el camino, y lo encontramos a la altura de la Calle 26 con Carrera 19 donde se realizó la última entrega la persona quedó tan agradecida y no sé si fue la manera en como conectaron los planetas, las estrellas y la energía de todo lo realizado que en modo de agradecimiento me obsequío esta pieza, que de ahora en adelante representa para mi gratitud y prosperidad en la vida, y dedico esta pieza a todas las personas que hicieron realidad este sueño.

Y no me queda nada mas que decir gracias!

La solución que he desarrollado con AWS CloudFormation tiene un propósito claro: simplificar la gestión de los servicios contenedores y garantizar que solo estén activos cuando realmente se necesita. Por ejemplo, si tienes servicios ECS que solo se usan durante horarios laborales, programar su detención fuera de ese periodo puede generar un impacto significativo en tu factura mensual.

Se ha integrado un registro histórico de los cambios en la configuración deseada de los servicios ECS en DynamoDB, esto con la finalidad de restaurar en el siguiente encendido la cantidad de tareas que tenía el contenedor previamente configurado. Adicionalmente estas funciones lambda evalúan si es festivo o no en COLOMBIA para validar si ejecuta o no el proceso, dependiendo de esto realizará o no la tarea de encendido (para ahorrarnos un día de consumo en los festivos).

Se debe tener en cuenta que aquí se utilizan varios componentes de AWS que puede que generen un mínimo consumo, respecto a tener los contenedores siempre corriendo, generando un ahorro considerable:

• CloudWatch
• DynamoDB
• Lambda

Para realizar el despliegue, debes subir el siguiente YAML como una plantilla de CloudFormation, ya sea dentro de la cuenta de AWS o como un StackSet dentro de la organización en las OUs correspondientes.

AWSTemplateFormatVersion: '2010-09-09'
Description: CloudFormation template to manage ECS services and DynamoDB with scheduled events

Resources:
  # Grupo de Logs para las Lambdas
  LogGroupStopECS:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: /aws/lambda/StopECSFunction
      RetentionInDays: 7

  LogGroupStartECS:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: /aws/lambda/StartECSFunction
      RetentionInDays: 7

  # Tabla DynamoDB
  ECSServiceDesiredCounts:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: ECSServiceDesiredCounts
      AttributeDefinitions:
        - AttributeName: ServiceClusterKey
          AttributeType: S
      KeySchema:
        - AttributeName: ServiceClusterKey
          KeyType: HASH
      BillingMode: PAY_PER_REQUEST

  # Rol para la Lambda de Apagado
  StopECSLambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: StopECSLambdaExecutionRole
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: StopECSPolicy
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Sid: LOGS
                Effect: Allow
                Action: logs:CreateLogGroup
                Resource: arn:aws:logs:*:*:* 
              - Sid: LOGS2
                Effect: Allow
                Action:
                  - logs:CreateLogStream
                  - logs:PutLogEvents
                Resource: arn:aws:logs:*:*:* 
              - Sid: ECS
                Effect: Allow
                Action:
                  - ecs:ListClusters
                  - ecs:ListServices
                  - ecs:UpdateService
                  - ecs:DescribeServices
                Resource: "*"
              - Sid: DYNAMODB
                Effect: Allow
                Action:
                  - dynamodb:GetItem
                  - dynamodb:PutItem
                Resource: "*"

  # Rol para la Lambda de Encendido  
  StartECSLambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: StartECSLambdaExecutionRole
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: StartECSPolicy
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Sid: LOGS
                Effect: Allow
                Action: logs:CreateLogGroup
                Resource: arn:aws:logs:*:*:* 
              - Sid: LOGS2
                Effect: Allow
                Action:
                  - logs:CreateLogStream 
                  - logs:PutLogEvents 
                Resource: arn:aws:logs:*:*:* 
              - Sid: ECS 
                Effect: Allow 
                Action:
                  - ecs:ListClusters 
                  - ecs:ListServices 
                  - ecs:UpdateService 
                  - ecs:DescribeServices 
                Resource: "*" 
              - Sid: DYNAMODB 
                Effect: Allow
                Action: dynamodb:GetItem
                Resource: "*"

  # Función Lambda para Apagar Servicios  
  StopECSFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: StopECSFunction  
      Description: "Función Lambda para detener servicios ECS y almacenar el conteo deseado en DynamoDB"
      Handler: index.lambda_handler  
      Timeout: 60
      Role: !GetAtt [StopECSLambdaExecutionRole, Arn]
      Runtime: python3.9
      Code:  
        ZipFile: |  
            import boto3
            import logging

            # Configuración del logger
            logger = logging.getLogger()
            logger.setLevel(logging.INFO)

            # Crea un manejador para enviar logs a CloudWatch
            ch = logging.StreamHandler()
            ch.setLevel(logging.INFO)
            formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
            ch.setFormatter(formatter)
            logger.addHandler(ch)

            # Inicializar recursos de AWS
            dynamodb = boto3.resource('dynamodb')
            ecs_client = boto3.client('ecs')

            # Nombre de la tabla DynamoDB
            DYNAMODB_TABLE_NAME = 'ECSServiceDesiredCounts'

            def get_desired_count(service_name, cluster_name):
                """Recupera el valor deseado del servicio desde DynamoDB usando ServiceClusterKey."""
                table = dynamodb.Table(DYNAMODB_TABLE_NAME)
                service_cluster_key = f"{service_name}:{cluster_name}"
                response = table.get_item(Key={'ServiceClusterKey': service_cluster_key})
                return response.get('Item', {}).get('DesiredCount', None)

            def set_desired_count(service_name, cluster_name, desired_count):
                """Almacena el valor deseado del servicio en DynamoDB usando ServiceClusterKey."""
                table = dynamodb.Table(DYNAMODB_TABLE_NAME)
                service_cluster_key = f"{service_name}:{cluster_name}"
                
                # Asegúrate de incluir DesiredCount en el ítem
                if desired_count is not None:
                    desired_count_int = int(desired_count)  # Asegúrate de que sea un int
                    table.put_item(Item={
                        'ServiceClusterKey': service_cluster_key,
                        'DesiredCount': desired_count_int  # Asegúrate de que este campo esté presente
                    })
                    logger.info(f"Se ha almacenado el desiredCount para {service_name} en {cluster_name}: {desired_count_int}")
                else:
                    logger.error(f"No se puede almacenar desiredCount porque es None para {service_name} en {cluster_name}.")

            def extract_service_name(service_arn):
                """Extrae el nombre del servicio del ARN."""
                return service_arn.split('/')[-1]

            def extract_cluster_name(cluster_arn):
                """Extrae el nombre del clúster del ARN."""
                return cluster_arn.split(':')[-1]

            def lambda_handler(event, context):
                logger.info("Iniciando la función Lambda para detener servicios en ECS.")
                
                try:
                    # Obtener la lista de clústeres
                    logger.info("Obteniendo la lista de clústeres.")
                    clusters_response = ecs_client.list_clusters()
                    clusters = clusters_response['clusterArns']
                    logger.info(f"Clusters encontrados: {[extract_cluster_name(c) for c in clusters]}")
                except Exception as e:
                    logger.error(f"Error al obtener clústeres: {str(e)}")
                    return {
                        'statusCode': 500,
                        'body': f"Error al obtener clústeres: {str(e)}"
                    }

                servicios_detener = []
                servicios_no_detener = []

                # Iterar sobre cada clúster y detener los servicios
                for cluster in clusters:
                    cluster_name = extract_cluster_name(cluster)
                    try:
                        logger.info(f"Listando servicios en el clúster: {cluster_name}.")
                        services_response = ecs_client.list_services(cluster=cluster)
                        services = services_response['serviceArns']
                        logger.info(f"Servicios encontrados en el clúster {cluster_name}: {[extract_service_name(s) for s in services]}")

                        # Detener cada servicio
                        for service_arn in services:
                            service_name = extract_service_name(service_arn)
                            
                            # Guardar el valor deseado actual antes de detenerlo
                            current_service_info = ecs_client.describe_services(cluster=cluster, services=[service_arn])
                            current_desired_count = current_service_info['services'][0]['desiredCount']
                            set_desired_count(service_name, cluster_name, current_desired_count)  # Almacena el valor actual
                            
                            try:
                                if current_desired_count == 0:
                                    logger.info(f"El servicio {service_name} ya está detenido en el clúster {cluster_name}.")
                                    continue
                                
                                logger.info(f"Deteniendo el servicio: {service_name}.")
                                ecs_client.update_service(cluster=cluster, service=service_arn, desiredCount=0)

                                # Verificar el estado del servicio después de la actualización
                                updated_service_after = ecs_client.describe_services(cluster=cluster, services=[service_arn])
                                if updated_service_after['services'][0]['desiredCount'] == 0:
                                    servicios_detener.append(service_name)
                                    logger.info(f"Servicio detenido correctamente: {service_name} en el clúster {cluster_name}.")
                                else:
                                    servicios_no_detener.append(service_name)
                                    logger.warning(f"El servicio {service_name} aún está activo en el clúster {cluster_name}.")

                            except Exception as e:
                                logger.error(f"Error al detener el servicio {service_name} en el clúster {cluster_name}: {str(e)}")
                                servicios_no_detener.append(service_name)

                    except Exception as e:
                        logger.error(f"Error al listar servicios en el clúster {cluster_name}: {str(e)}")

                if servicios_detener:
                    logger.info(f"Servicios detenidos correctamente: {servicios_detener}")
                if servicios_no_detener:
                    logger.warning(f"No se pudieron detener los siguientes servicios: {servicios_no_detener}")

                logger.info("Proceso de detención de servicios completado.")
                
                return {
                    'statusCode': 200,
                    'body': 'Proceso de detención de servicios completado.'
                }


  # Función Lambda para Encender Servicios  
  StartECSFunction:
    Type: AWS::Lambda::Function     
    Properties:
      FunctionName: StartECSFunction
      Description: "Función Lambda para encender servicios ECS con el conteo deseado almacenado en DynamoDB"      
      Handler: index.lambda_handler     
      Timeout: 60
      Role: !GetAtt [StartECSLambdaExecutionRole, Arn]
      Runtime: python3.9
      Code: 
        ZipFile: | 
            import boto3
            import logging
            import urllib.request
            import json
            from datetime import datetime

            # Configuración del logger
            logger = logging.getLogger()
            logger.setLevel(logging.INFO)

            # Crea un manejador para enviar logs a CloudWatch
            ch = logging.StreamHandler()
            ch.setLevel(logging.INFO)
            formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
            ch.setFormatter(formatter)
            logger.addHandler(ch)

            # Inicializar recursos de AWS
            dynamodb = boto3.resource('dynamodb')
            ecs_client = boto3.client('ecs')

            # Nombre de la tabla DynamoDB
            DYNAMODB_TABLE_NAME = 'ECSServiceDesiredCounts'

            # Función para verificar si hoy es festivo
            def is_holiday():
                today = datetime.now().strftime('%Y-%m-%d')
                year = datetime.now().year
                
                # Nueva URL para consultar días festivos
                url = f"https://api.generadordni.es/v2/holidays/holidays?country=CO&year={year}"
                
                logger.info(f"Consultando la URL: {url}")
                
                try:
                    with urllib.request.urlopen(url) as response:
                        data = response.read()
                        holidays = json.loads(data)
                    
                    # Verificar si la fecha actual está en la lista de días festivos
                    is_holiday = any(holiday['date'] == today for holiday in holidays)
                    return is_holiday
                except urllib.error.HTTPError as e:
                    error_message = f"HTTP Error {e.code}: {e.reason}. Response: {e.read().decode()}"
                    logger.error(f"Error al consultar los días festivos: {error_message}")
                    return False
                except Exception as e:
                    logger.error(f"Error desconocido al consultar los días festivos: {e}")
                    return False

            def get_desired_count(service_name, cluster_name):
                """Recupera el valor deseado del servicio desde DynamoDB usando ServiceClusterKey."""
                table = dynamodb.Table(DYNAMODB_TABLE_NAME)
                service_cluster_key = f"{service_name}:{cluster_name}"
                response = table.get_item(Key={'ServiceClusterKey': service_cluster_key})
                return response.get('Item', {}).get('DesiredCount', None)

            def extract_service_name(service_arn):
                """Extrae el nombre del servicio del ARN."""
                return service_arn.split('/')[-1]

            def extract_cluster_name(cluster_arn):
                """Extrae el nombre del clúster del ARN."""
                return cluster_arn.split(':')[-1]

            def lambda_handler(event, context):
                # Obtener el día de hoy
                today = datetime.now().strftime('%A, %d de %B de %Y')
                logger.info(f"Evaluando si hoy ({today}) es un día festivo.")
                
                # Verificar si hoy es festivo
                if is_holiday():
                    logger.info(f"Hoy es un día festivo ({today}). No se ejecutará el proceso.")
                    return {
                        'statusCode': 200,
                        'body': f"Hoy es un día festivo ({today}). No se ejecutará el proceso."
                    }

                logger.info(f"Hoy NO es un día festivo ({today}). Procediendo con la ejecución del proceso.")
                
                # Continuar con el proceso si no es festivo
                try:
                    # Obtener la lista de clústeres
                    logger.info("Obteniendo la lista de clústeres.")
                    clusters_response = ecs_client.list_clusters()
                    clusters = clusters_response['clusterArns']
                    logger.info(f"Clusters encontrados: {[extract_cluster_name(c) for c in clusters]}")
                except Exception as e:
                    logger.error(f"Error al obtener clústeres: {str(e)}")
                    return {
                        'statusCode': 500,
                        'body': f"Error al obtener clústeres: {str(e)}"
                    }

                servicios_iniciar = []
                servicios_no_iniciar = []

                # Iterar sobre cada clúster y restaurar los servicios
                for cluster in clusters:
                    cluster_name = extract_cluster_name(cluster)
                    
                    try:
                        logger.info(f"Listando servicios en el clúster: {cluster_name}.")
                        services_response = ecs_client.list_services(cluster=cluster)
                        services = services_response['serviceArns']
                        logger.info(f"Servicios encontrados en el clúster {cluster_name}: {[extract_service_name(s) for s in services]}")
                        
                        # Reiniciar cada servicio
                        for service_arn in services:
                            service_name = extract_service_name(service_arn)
                            desired_count = get_desired_count(service_name, cluster_name)
                            
                            if desired_count is not None:
                                try:
                                    desired_count_int = int(desired_count)  # Asegurarse de que sea un int
                                    logger.info(f"Iniciando el servicio: {service_name} con desiredCount: {desired_count_int}.")
                                    
                                    # Establecer desiredCount al valor original
                                    ecs_client.update_service(cluster=cluster, service=service_arn, desiredCount=desired_count_int)
                                    
                                    # Verificar el estado del servicio después de la actualización
                                    updated_service = ecs_client.describe_services(cluster=cluster, services=[service_arn])
                                    if updated_service['services'][0]['desiredCount'] == desired_count_int:
                                        servicios_iniciar.append(service_name)
                                        logger.info(f"Servicio iniciado correctamente: {service_name} en el clúster {cluster_name}.")
                                    else:
                                        servicios_no_iniciar.append(service_name)
                                        logger.warning(f"No se pudo iniciar el servicio {service_name} en el clúster {cluster_name}.")
                                except Exception as e:
                                    logger.error(f"Error al iniciar el servicio {service_name} en el clúster {cluster_name}: {str(e)}")
                                    servicios_no_iniciar.append(service_name)
                            else:
                                logger.warning(f"No se encontró un valor deseado para el servicio: {service_name}")
                    
                    except Exception as e:
                        logger.error(f"Error al listar servicios en el clúster {cluster_name}: {str(e)}")

                if servicios_iniciar:
                    logger.info(f"Servicios iniciados correctamente: {servicios_iniciar}")
                
                if servicios_no_iniciar:
                    logger.warning(f"No se pudieron iniciar los siguientes servicios: {servicios_no_iniciar}")

                logger.info("Proceso de inicio de servicios completado.")
                
                return {
                    'statusCode': 200,
                    'body': 'Proceso de inicio de servicios completado.'
                }




  # Regla EventBridge para Apagar Servicios (todos los días a las 8 PM hora Colombia)
  StopECSRule:
    Type: AWS::Events::Rule
    Properties:
      Description: "Regla para apagar ECS"
      ScheduleExpression: cron(0 1 ? * TUE-SAT *) # 8 PM hora Colombia (UTC-5)Type: Schedule
      State: ENABLED
      Targets:
        - Arn: !GetAtt [StopECSFunction, Arn]
          Id: "TargetFunctionV1"

  # Regla EventBridge para Encender Servicios (de lunes a viernes a las 7 AM hora Colombia)
  StartECSRule:
    Type: AWS::Events::Rule 
    Properties:
      Description: "Regla para encender ECS"
      ScheduleExpression: cron(0 12 ? * MON-FRI *) # 7AM hora Colombia (UTC-5)
      State: ENABLED
      Targets:
        - Arn: !GetAtt [StartECSFunction, Arn]
          Id: "TargetFunctionV1"

  #Asociar trigger de EventBridge a Lambda
  StopECSPermission:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunction
      FunctionName: !Ref StopECSFunction
      Principal: events.amazonaws.com
      SourceArn: !GetAtt StopECSRule.Arn

  #Asociar trigger de EventBridge a Lambda
  StartECSPermission:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunction
      FunctionName: !Ref StartECSFunction
      Principal: events.amazonaws.com
      SourceArn: !GetAtt StartECSRule.Arn          

Outputs:
  StopECSFunctionArn:
    Description: "ARN of the Stop ECS Lambda function"
    Value: !GetAtt [StopECSFunction, Arn]

  StartECSFunctionArn:
    Description: "ARN of the Start ECS Lambda function"
    Value: !GetAtt [StartECSFunction, Arn]

Amazon SageMaker > Admin configurations > Lifecycle configurations > Create configuration

Aquí se deberá pegar el siguiente código, que lo que hará es de manera continua revisar el estado del kernel, y contabilizar conforme los segundos que se confifguren, si se está realizando alguna tarea dentro de Jupiter, si no hay nada en ejecución una vez transcurrido el tiempo, el entorno se apagará:

#!/bin/bash
set -eux
ASI_VERSION=0.3.1
# User variables [update as needed]
####################
### Ajustar el tiempo, tener en cuenta esto!!! https://github.com/aws-samples/sagemaker-studio-lifecycle-config-examples/issues/17#issuecomment-2364659767
####################
IDLE_TIME_IN_SECONDS=1200       # The max time (in seconds) the JupyterLab app can stay idle before being terminated.
# User variables - advanced [update only if needed]
IGNORE_CONNECTIONS=True         # Set to False if you want to consider idle JL sessions with active connections as not idle.
SKIP_TERMINALS=False            # Set to True if you want to skip any idleness check on Jupyter terminals.
# System variables [do not change if not needed]
JL_HOSTNAME=0.0.0.0
JL_PORT=8888
JL_BASE_URL=/jupyterlab/default/
CONDA_HOME=/opt/conda/bin
LOG_FILE=/var/log/apps/app_container.log # Writing to app_container.log delivers logs to CW logs.
SOLUTION_DIR=/var/tmp/auto-stop-idle # Do not use /home/sagemaker-user
STATE_FILE=$SOLUTION_DIR/auto_stop_idle.st
PYTHON_PACKAGE=sagemaker_studio_jlab_auto_stop_idle-$ASI_VERSION.tar.gz
PYTHON_SCRIPT_PATH=$SOLUTION_DIR/sagemaker_studio_jlab_auto_stop_idle/auto_stop_idle.py
CHECK_KERNEL_ACTIVITY_SCRIPT=/var/tmp/check_kernel_activity.sh
# Check if cron needs to be installed
status="$(dpkg-query -W --showformat='${db:Status-Status}' "cron" 2>&1)" || true
if [ ! $? = 0 ] || [ ! "$status" = installed ]; then
	# Fixing invoke-rc.d: policy-rc.d denied execution of restart.
	sudo /bin/bash -c "echo '#!/bin/sh
	exit 0' > /usr/sbin/policy-rc.d"
	# Installing cron.
	echo "Installing cron..."
	sudo apt install cron
else
	echo "Package cron is already installed."
        # start/restart the service.
	sudo service cron restart
fi
# Creating solution directory.
sudo mkdir -p $SOLUTION_DIR
# Downloading autostop idle Python package.
echo "Downloading autostop idle Python package..."
curl -LO --output-dir /var/tmp/ https://github.com/aws-samples/sagemaker-studio-apps-lifecycle-config-examples/releases/download/v$ASI_VERSION/$PYTHON_PACKAGE 
sudo $CONDA_HOME/pip install -U -t $SOLUTION_DIR /var/tmp/$PYTHON_PACKAGE
# Setting container credential URI variable to /etc/environment to make it available to cron
sudo /bin/bash -c "echo 'AWS_CONTAINER_CREDENTIALS_RELATIVE_URI=$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI' >> /etc/environment"
# Create a script to check for kernel activity
sudo tee $CHECK_KERNEL_ACTIVITY_SCRIPT > /dev/null <<EOF
#!/bin/bash
# Set the notebook server hostname and port
JL_HOSTNAME=0.0.0.0
JL_PORT=8888
JL_TOKEN_FILE="/var/tmp/jupyter.token"
# Get the Jupyter token
TOKEN=\$(jupyter server list | grep -oP 'token=\K[^ ]+')
# Fetch list of kernels using Jupyter REST API
KERNELS=\$(curl -s -H "Authorization: Token \$TOKEN" "http://\$JL_HOSTNAME:\$JL_PORT/api/kernels " | jq -r '.[] | .execution_state')
# Check if any kernel is in a busy or executing state
for KERNEL_STATUS in \$KERNELS; do
    if [[ "\$KERNEL_STATUS" == "busy" || "\$KERNEL_STATUS" == "executing" ]]; then
        echo "Kernel is active. Autostop will not proceed."
        exit 1
    fi
done
echo "No active kernels found."
exit 0
EOF
# Make the kernel activity script executable
sudo chmod +x $CHECK_KERNEL_ACTIVITY_SCRIPT
# Add script to crontab for root.
echo "Adding autostop idle script with kernel monitoring to crontab..."
echo "*/2 * * * * /bin/bash -c '$CHECK_KERNEL_ACTIVITY_SCRIPT && $CONDA_HOME/python $PYTHON_SCRIPT_PATH --idle-time $IDLE_TIME_IN_SECONDS --hostname $JL_HOSTNAME \
--port $JL_PORT --base-url $JL_BASE_URL --ignore-connections $IGNORE_CONNECTIONS \
--skip-terminals $SKIP_TERMINALS --state-file-path $STATE_FILE >> $LOG_FILE'" | sudo crontab -

El código anterior está corregido, ya que el código fuente, apaga el entorno desde el tiempo que se inicia el entorno, y no es lo que se necesita en este caso.

Una vez guardado el LifeCycle, se deberá atachar este al entorno de trabajo, esto se realiza en la opción:

Amazon SageMaker > Admin configurations > Domains > Nombre Dominio > Enviroment > Lifecycle configurations for personal Studio apps > Attach

Allí se deberá seleccionar el LifeCycle configurado y seleccionar «Attach to domain» una vez guardado, se deberá seleccionar este por defecto para el entorno configurado, para ello en la lista se deberá seleccioanr el LifeCycle configurado y posteriormente seleccioanr «Set as default»

Ya se podrá iniciar el entorno de trabajo y este se detendrá automáticamente una vez se complete el proceso de ejecución con el tiempo definido. Tener en cuent aque si hay trabajos de Glue en curso, estos continuarán procesando la información en segundo plano, así el entorno de SageMaker se encuentre detenido, ya que este opera como un servicio independiente.

sudo dd if=/Users/im/Desktop/NOMBRE_DE_LA_IMAGEN.ISO of=/dev/disk4 bs=1024k status=progress

Recuerda cambiar el «disk4» por el número de disco asociado a la memoria USB

El proceso de instalación es bastante sencillo, solo debemos tener en cuenta que debes desactivar el modo seguro en la BIOS de tu equipo, sin este paso NADA funcionará, este proceso varía en cada computador, así que deberás buscar en internet como hacerlo.

Luego de haber desactivado el modo seguro, abre una terminal y coloca lo siguiente:

sudo apt update
sudo apt install -y dkms git
git clone https://github.com/tomaspinho/rtl8821ce.git
cd rtl8821ce/
sudo ./dkms-install.sh
sudo modprobe 8821ce
iwconfig

Y reinicia tu Ubuntu, ya con esto debes tener WiFi, recuerda tener desactivado el modo seguro en tu BIOS

apt install docker docker.io git docker-compose
docker pull ocsinventory/ocsinventory-docker-image:latest
git clone https://github.com/OCSInventory-NG/OCSInventory-Docker-Image.git
cd OCSInventory-Docker-Image/2.7/
docker-compose up -d
docker ps

Con este último comando debemos validar que esté corriendo el servicio, ejemplo:

Una vez esté corriendo ingresaremos e iniciaremos sesión en la plataforma de OCS Inventory vía web en: http://ip_servidor/ocsreports/ con el usuario admin y la contrasela admin

Instalación de agente en Ubuntu

Luego procederemos a instalar los agentes en nuestros clientes Ubuntu, el proceso es muy sencillo, solo abrimos la terminal y colocamos lo siguiente:

apt install libmodule-install-perl dmidecode libxml-simple-perl libcompress-zlib-perl libnet-ip-perl libwww-perl libdigest-md5-perl libdata-uuid-perl
apt install ocsinventory-agent

En el momento de la instalación nos pedirá el método de conexión, donde se seleccionará http y luego la URL de conexión aquí se debe poner lo siguiente (cuidado la URL cambia) http://ip_servidor/ocsinventory

El archivo de configuración quedará guardado en la siguiente ruta (por si necesitas ajustar algo adicional)

/etc/ocsinventory/ocsinventory-agent.cfg

Instalación de agente en Unix

Ver: https://wiki.ocsinventory-ng.org/

Ya luego aparecerán los clientes o agentes conectados al servidor entregando el inventario de las máquinas.

Advertencia: Durante el proceso el mouse se desactivará así que no te asustes

rmmod hid_magicmouse
modprobe hid_magicmouse scroll_acceleration=1 scroll_speed=55

Puedes ajustar este valor de 0 a 63, entonces prueba y ajusta según corresponda.

Si deseas desactivar el click cental (en verdad muy molesto) realiza esto:

rmmod hid_magicmouse
modprobe hid_magicmouse emulate_3button=0

Y ya para que los cambios sean permantes crea el siguiente archivo con el siguiente contenido:

nano  /etc/modprobe.d/hid_magicmouse.conf 
modprobe hid_magicmouse scroll_acceleration=1 scroll_speed=55
modprobe hid_magicmouse emulate_3button=0

Así que manos a la obra:

apt update && apt upgrade -y
apt install build-essential libpcre3 libpcre3-dev libssl-dev nginx libnginx-mod-rtmp ffmpeg -y

Editamos el archivo de configuración de nginx y colocamos esta sección al final.

rtmp {
        server {
                listen 1935;
                chunk_size 4096;
                notify_method get;

                application live {
                             on_publish http://localhost/auth;
                             live on;
                             #Si quieres grabar cambia "record" a "all"
                             record off;
                             #Se define el directorio para grabar
                             record_path /var/www/html/recordings;
                             record_unique on;
                             #Se define canal de transmision
                             push rtmp://localhost/youtube;
                }
                # YouTube Stream Application  
                      application youtube {
                          live on;
                          record off;
                          #Only allow localhost to publish
                          allow publish 127.0.0.1;
                          deny publish all;
                          # Push URL with the YouTube stream key
                          push rtmp://a.rtmp.youtube.com/live2/<TU_LLAVE_API>;
                      }
        }
}

Creamos el directorio de grabaciones:

mkdir -p /var/www/html/recordings
chown -R www-data:www-data /var/www/html/recordings/

Se configura el canal de transmisión hacia nginx

nano /etc/nginx/sites-enabled/default

En la sección «server» después de definir los puertos «listen» debe ir lo siguiente:

location /auth {
        if ($arg_pwd = 'una_contraseña_evitar_simbolos') {
            return 200;
            }
            return 401;
}

Y reiniciamos el servicio nginx:

systemctl restart nginx.service

Configurando OBS con nuestro servidor NGINX

En la sección Controles de la interfaz, haga clic en «Ajustes» o «Configuración» para ingresar a la interfaz de configuración de OBS.

Ingrese la pestaña «Emisión» e ingrese la Información sobre su instancia de transmisión:

• Servicio: Personalizado
• Server: rtmp://ip_publica_servidor/live
• Clave de transmisión: nombre_stream?pwd=una_contraseña_evitar_simbolos

Guarde la configuración y configure su escena en OBS Studio.

Cuando esté listo, comience a transmitir al servidor haciendo clic en Iniciar transmisión en la sección Controles de OBS.

Configurar canales MultiStreaming

Abrir el archivo de configuración de nginx:

nano /etc/nginx/nginx.conf

Buscar la sección «Stream Application» y ajustar URL’s y API_KEYS según corresponda:

# Youtube Stream Application  
application youtube {
  live on;
  record off;
  #Only allow localhost to publish
  allow publish 127.0.0.1;
  deny publish all;
  # Push URL with the YouTube stream key
  push rtmp://a.rtmp.youtube.com/live2/<TU_LLAVE_API>;
}

Agregar canales extra (si es necesario), en caso contrario ir al final para reiniciar servicios

apt-get install stunnel4 -y
sudo nano /etc/default/stunnel4

Aquí cambia ENABLE de 0 a 1

ENABLED=1

Editamos ahora el stunnel

nano /etc/stunnel/stunnel.conf

Y colocamos lo siguiente:

pid = /var/run/stunnel4/stunnel.pid
output = /var/log/stunnel4/stunnel.log


setuid = stunnel4
setgid = stunnel4

# https://www.stunnel.org/faq.html
socket = r:TCP_NODELAY=1
socket = l:TCP_NODELAY=1

debug = 4

[fb-live]
client = yes
accept = 127.0.0.1:1936
connect = live-api-s.facebook.com:443
verifyChain = no

Iniciamos servicios:

systemctl enable stunnel4.service
systemctl restart stunnel4.service
systemctl status stunnel4.service

Agregamos el canal de Facebook por rtmps

nano /etc/nginx/nginx.conf

En la sección donde se define la aplicación «live» se debe adicionar:

push rtmp://localhost/facebook;

Y debajo de la aplicación ya creada, en este caso YouTube, después de que finaliza la sección ponemos:

# Facebook Stream Application  
application facebook {
  live on;
  record off;

  #Only allow localhost to publish
  allow publish 127.0.0.1;
  deny publish all;
  # Push URL with the Facebook stream key
  push rtmp://127.0.0.1:1936/rtmp/<facebook_stream_key>;
}

Reiniciamos servicio de nginx:

systemctl restart nginx.service
systemctl status nginx.service

Desde un nivel alto, Stunnel y NGINX ahora deberían funcionar así:

 ____________        ____________        ____________        ____________  
| Streaming  |      |            |      |            |      |  Facebook  | 
|   Source   | ---> |   NGINX    | ---> |   stunnel  | ---> |    Live    | 
|____________|      |____________|      |____________|      |____________|

 

Si requieres adicionar más canales de Streaming, puedes hacerlo del mismo modo siguiendo el esquema anterior. Al final ya estarás transmitiendo desde OBS pasando por un proxy NGINX hacia los canales necesarios:

Se puede probar el Live en Streaming por ejemplo usando VLC, colocando la URL de nuestro servidor:

rtmp://ip_servidor_o_dominio/live/nombre_stream

En mi caso para la prueba era:

rtmp://streaming.flisolbogota.org/live/flisol

Para construir nuestra Alexa necesitamos:

• Rasberry Pi 3B p 3B+
• ReSpeaker 2 Mics Pi HAT (Comprar aquí)
• Parlantes
• Teclado
• Mouse
• Pantalla con soporte HDMI

Paso 1) Primero (recomendamos hacer la instalación con la imágen de disco de seeed que puede descargar en aquí, si deseas usar la imágen oficial de raspberry, puedes seguir con la oficial, aunque puedes tener problemas con el Kernel) debemos instalar Raspbian con Noobs (versión Desktop), por lo cual puede seguir la siguiente documentación: https://www.raspberrypi.org/documentation/installation/noobs.md y finalmente realizamos conexión a nuestra red de Internet. Y luego cambiamos los repositorios que allí ya trae por los oficiales de Raspbian en el archivo /etc/apt/sources.list

deb http://archive.raspbian.org/raspbian stretch main contrib non-free
deb-src http://archive.raspbian.org/raspbian stretch main contrib non-free

Luego adicionamos la llave de los repositorios y actualizamos nuestro sistema:

wget https://archive.raspbian.org/raspbian.public.key -O - | sudo apt-key add -
sudo apt update
sudo apt dist-upgrade
reboot

Paso 2) Ahora que nuestro dispositivo tiene conectividad a Internet, abra un terminal y verificamos que debe aparecer en el directorio /home/pi. Copie y pegue el siguiente comando en la ventana de su terminal y presione Enter.

wget https://raw.githubusercontent.com/alexa/avs-device-sdk/master/tools/Install/setup.sh
wget https://raw.githubusercontent.com/alexa/avs-device-sdk/master/tools/Install/pi.sh
wget https://raw.githubusercontent.com/alexa/avs-device-sdk/master/tools/Install/genConfig.sh

Paso 3) Creamos en el directorio /home/pi un archivo llamado config.txt y le agregamos el siguiente contenido:

DEVICE_SERIAL_NUMBER="123456"
CLIENT_ID=""
PRODUCT_ID=""

Paso 4) Es hora de copiar y pegar las credenciales de su producto en su archivo de configuración. En su navegador web, ingrese al panel de AVS Amazon donde puede ver todos sus productos asociados con su cuenta de desarrollador. Si ha cerrado sesión, vuelva a iniciar sesión y haga clic en el enlace de la Consola de desarrollador en la esquina superior derecha de su navegador. Luego haga clic en el botón «SERVICIO DE VOZ DE ALEXA» en la navegación para regresar a su AVS Console. Ingresamos a la opción CREATE PRODUCT y llenamos los campos con la siguiente información:

Product Name: RaspberryPi
Product ID: RaspberryPi
CHECK en Device with Alexa built-in
Will your device use a companion app: No
Product category: Other
Brief product description: RaspberryPi
How will end users interact with your product: CHECK in Touch-initiated & Hands-free
Do you intend to distribute this product commercially: No
Will your device be used for Alexa for Business: No
Is this a children’s product or is it otherwise directed to children younger than 13 years old: No

Presionamos la opción Next y luego presionamos en CREATE NEW PROFILE, en los dos campos que aparecen colocamos: RaspberryPi y NEXT

Luego aceptamos términos y condiciones (si estás de acuerdo, claro está) CHECK en I agree to theAmazon Developer Services Agreement,including theAlexa Voice Service Program Requirements.  Y presionamos la opción FINISH

Paso 5) Abrimos el archivo config.txt y en los campos en cuestión colocamos:

PRODUCT_ID="RaspberryPi"
CLIENT_ID=VER_SIGUIENTE_IMAGEN

Haga clic en el enlace Perfil de seguridad en la sección Detalles y administración, luego vaya a Otros dispositivos y plataformas desde la Web – Android / Kindle – iOS – Otras opciones de dispositivos y plataformas.

El archivo debería quedar algo como lo siguiente, guardamos cambios…

DEVICE_SERIAL_NUMBER="1234"
CLIENT_ID="amzn1.application-oa2-client.12345678901234567890123456789012"
PRODUCT_ID="RaspberryPi"

Adicionalmente descargue el archivo de configuración JSON que ofrece AVS de Amazon, y ubíquelo en el mismo directorio /home/pi/

Paso 6) Abre la terminal y coloca el siguiente comando, está pendiente de la shell ya que hará algunas preguntas donde deberemos aceptar, este proceso de compilación tardará algún tiempo… así que paciencia…

cd /home/pi/
sudo bash setup.sh config.json [-s 123456]

Luego hará una pregunta, escribimos AGREE y continuamos el proceso, al final visualizaremos lo siguiente, si todo salió en orden:

cd /home/pi/
sudo bash startsample.sh

Nota: Si la ventana de su terminal muestra repetidamente el mensaje de verificación de autorización, desplácese hacia arriba hasta que encuentre el código requerido. Debe mantener la aplicación de muestra en ejecución mientras ingresa el código.

Para finalizar y empezar a hablar con Alexa, colocamos el siguiente comando:

sudo bash startsample.sh

Para cambiar el idioma presionamos la tecla ‘c’ y seguimos los pasos que el asistente indica. Feliz Hacking!  Puedes configurar otras opciones más en: https://alexa.amazon.com/spa/index.html

Archivos Necesarios:

• Mi Unlock
• Super SU (ZIP)
• WTRP mido
• lazyflasher-no-verity-opt-encrypt.zip
• ★ Redmi Note 4 Qualcomm Latest Global Stable Version Fastboot File Download (este será necesario en caso de algún problema para restaurar el teléfono vía fastboot)
• MIUI ROM Flashing Tool (este será necesario en caso de algún problema para restaurar el teléfono vía fastboot)

Requisitos:

• Tener instalado y configurado ADB – Fastboot en nuestro equipo
• Tener batería a mas del 50%

Paso 1

Copiar el archivo lazyflasher-no-verity-opt-encrypt.zip y el ZIP de Super SU (ZIP) en la raiz de nuestra memoria en el teléfino, Descomprimir Mi Unlock, iniciar el teléfono en modo fastboot (Vol – y Power) conectar vía USB y seguir los pasos de la aplicación Mi Unlock

Paso 2

Teniendo el teléfono en modo fastboot debes colocar el siguiente comando:

fastboot flash recovery twrp-nombrearchivo.img

Paso 3

Iniciar modo recovery TWRP (Power Vol + y Power) y desde allí ir al apartado de instalación e instalar lazyflasher-no-verity-opt-encrypt.zip y el ZIP de Super SU (ZIP).

Paso 4

Disfrutar de los poderes root

Si tienes algún problema durante el proceso o el teléofno no inicia deberás reinstalar todo el sistema operativo del teléfono, para ello debes descomprimir todos los archivos descargados para «★ Redmi Note 4 Qualcomm Latest Global Stable Version Fastboot File Download» abrir la App MIUI ROM Flashing Tool y teniendo el teléfono en modo Fastboot debemos buscar la ruta de los archivos que hemos descomprimido e iniciar dede la App la restauración.

DISCLAIMER: No me hago responsable por los daños que pueda tener tu teléfono o brickeos, esto lo harás bajo tu responsabilidad

La instalación es muy sencilla, necesitamos lo siguiente:

1. Tener instalado adb y fastboot en nuestro equipo
2. Archivos necesarios, incluye: bootloader, Android Oreo for Xiaomi A1 y Recuperación de sistema Stock ROM by Xiaomi: https://goo.gl/c7JUP6

Para iniciar recomiendo tomar backup de TODA la información que tengas en el teléfono, descomprimir la carpeta que está en el link anterior y navegamos por shell o cmd hasta dicha carpeta, una vez realizado esto ponemos el teléfono en modo fastboot (Power y Vol – por 5 segundos) una vez conectado por USB colocamos los siguientes comandos:

fastboot oem unlock
fastboot boot recovery-3.1.1-1.img

Luego de estar dentro del TWRP debes seguir TODOS los siguientes pasos:

• Seleccionar la opción de backup y hacer backup de la partición mas pequeña
• Copiar y pegar (desde el PC) la carpeta (archivo bajado anteriormente) [UNNOFICIAL] AOSP OREO – tissot  dentro de la ruta TWRP/Backup/ipdelbackup/ (del celular) y eliminar el archivo que esté antes de copiar nuestro nuevo directorio (en el celular)
• Regresar al inicio del TWRP y hacer Wipe a: Data, System, Caché
• Regresar al inicio y restaurar [UNNOFICIAL] AOSP OREO – tissot
• Disfrutar Android Oreo -Es posible que el boot tome algunos minutos, si va mas de 10 minutos y no inicia, forzar el reinicio manualmente –

Listo #AndroidOreo #XiaomiA1

Una publicación compartida de Jhosman Lizarazo (@namsohj) el 14 de Dic de 2017 a la(s) 9:16 PST

Así de simple como lo indica el título, por culpa de los animalistas que buscan un palacio 5 estrellas para los peluditos sin hogar, es que muchos de estos animalitos se quedan sin hogar.

Si bien es cierto que no está bien que la gente compre mascotas para tener en su hogar, mal hacen estas personas poniendo tantas trabas para poder adoptar a una mascota, por lo cual les cuento he querido adoptar a una mascota donde la verdad es mas fácil sacar un crédito en un banco por unos COP $200.000.000 que poder tomar y darle un buen hogar a un animal sin casa.

Las trabas inician desde que realizas contacto con quien da en adopción al animal donde te preguntan:

• Donde vives?
• En que trabajas?
• Ganas bien?

Bueno, estas preguntas realmente las hace un bando, y si uno está buscando una mascota de manera responsable es por que cumple estos tres primeros pasos, si bien es cierto que no todos pueden cumplir por lo menos lo del dinero para poder mantener a un animalito de esto, es muy odioso de parte de estas personas denigrar a una persona por su condición de vida, sus finanzas etc.

Les cuento si buscan a un animalito y cumplen las dos últimas partes, pero para la primera es que vives por ejemplo al sur de Bogotá o al Occidente o zonas donde hay mucha población no de darán nada en adopción, y si buscas alguna raza en especial peor, por que lo primero que piensan ellos es que buscas para sacarles crias y venderlas, personalmente quien piensa así realmente es por que tiene una mente retorcida. El cuento es que el proceso para adoptar es:

• Debes llenar un formulario donde entregas el 100% de tus datos personales que deben ser 100% verídicos a una persona que ni conoces, con tu dirección, teléfonos, datos de personas reales cercanas a tí (aquí ya se está vulnerando el derecho a la privacidad) este proceso lo hacen con unas 20 personas y quien sabe que harán con esta información
• El segundo paso es que si pasas el primer filtro (cumples los 3 primeros puntos – vives en un palacio-) deciden hacerte una visita para ver donde va a estar el animalito, en este punto me parece mas grave aún por que si ya estás en un palacio excelente para el animal, un tercero (que ni conoces) debe visitar tu casa y esperar a que no pase nada extraño, esto mismo lo hacen con todos los que pasaron el filtro.
• Finalmente si vives prácticamente en el palacio de Nariño te entregan en animal con mas condiciones a futuro que mejor ni les cuento.

Ahora bien, si medio cumples las condiciones pero vives en una zona con mucha población te dicen que mejor adoptes otro tipo de perro o gato que no estás buscando, como si esos no se mereciera vivir en los palacios que ellos buscan. Si por suerte te dan en adopción el animalito a cambio de piden que les compres un bulto de comida en tiendas de ellos, o en veterinarias de ellos los mandes a esterilizar o les hagas exámenes (mercado negro, de lo cual me abstengo de comentarios)

La historia viene a que por surte y mucha dedicación logré dar con una persona que no es odiosa, piensa en la vida y futuro de los animales quien de manera responsable me dio en adopción una Beagle que por cierto se recibió en condición de esterilizar de manera inmediata (que debe ser lo mínimo que se debe exigir) y ahora goza de una excelente vida, se recupera de lesiones que tenía en sus patas traseras por posible maltrato de sus dueños anteriores y ella es feliz ahora. Se entregó en adopción sin problema alguno, sin pasar un proceso mas tedioso que un préstamo en un banco y se le pudo dar un hogar digno para esta orejona. Este post es un llamado a esos animalistas que dan en adopción mascotas, que ni pueden mantener por la cantidad que tienen, no sean odiosos, piensen en los animalitos y denles la oportunidad de una vida diferente.

Ella es Anny, una beagle que necesitaba urgente un hogar, alguien que le diera cariño y buena vida, ahora está en nuestro hogar y está feliz. Tiene aproximadamente un año de vida, es muy noble.

Aquí encontrarás respuestas a todas tus preguntas, lee antes de cualquier cosa.

• Como pagar en AliExpress
• Como rastrear mi envío de AliExpress
• Como comprar de manera segura en AliExpress
• Proceso de entrega de pedidos en Colombia
• Puedo comprar Celulares en AliExpress?
• Si mi pedido nunca llegó a Colombia o no lo recibí por parte de la Tienda de AliExpress que hago?

1. Bajar la versión Beta de telegram: telegram.me/betatest_tg
2. Abrir la App «Telegram Beta»
3. Iniciar sesión con tu cuenta de telegram
4. Ir a ajustes y pulsar «Switch Backend», confirma y se reinicia la sesion
5. Volver a poner el número y código de confirmación. Con esto verás todo vacío en tu chat por que te encuentras en el servidor en pruebas de telegram, y para probar la llamada con alguien requiere que tenga alias en ese servidor debes crearte un @ en la configuración de Telegram Beta, la otra persona debe tener telegram beta y hacer lo mismo.
6. Llamar! 😀

Estas son capturas de pantallas de las llamadas funcionando dale en las flechas para cambiar la imagen.

Varios usuarios de Twitter le han preguntado al creador de telegram por esta funcionalidad vía Twitter y el ha respondido solo «Lo haremos» sin dar mas detalles:

@adinhorman9 Hey there. Thanks. We will.

— Pavel Durov (@durov) 13 de enero de 2017

Solo nos quedará esperar a que se cumpla este gran sueño!