Registro de Usuarios con AWS Cognito en iOS (sin Amplify)

Posted on by admin

Si estás comenzando a trabajar con AWS Cognito en iOS, probablemente te has preguntado: ¿Cómo implemento un sistema de registro de usuarios desde cero? En este artículo vamos a construir paso a paso una funcionalidad de registro usando AWS Cognito SDK directamente, sin Amplify.

Como siempre, mantendremos la implementación clara, sencilla y accesible. No nos enfocaremos en arquitecturas complejas (MVVM, Clean Architecture, etc.), sino en entender cómo funciona Cognito por dentro.

¿Qué vamos a construir?

Una pantalla de registro simple que permita: – Ingresar email – Ingresar contraseña – Confirmar contraseña – Botón de registro.

Por ahora, solo crearemos la interfaz. En los siguientes pasos agregaremos la funcionalidad real con Cognito.

Requisitos previos

  • Xcode instalado (versión 15 o superior)
  • Conocimientos básicos de SwiftUI
  • Una cuenta de AWS (la crearemos más adelante cuando conectemos Cognito)

Paso 1: Creando la interfaz de registro

Primero, vamos a crear una vista simple y limpia para el registro de usuarios. Creamos un archivo llamado RegisterView.swift:

import SwiftUI

struct RegisterView: View {
    @State private var email: String = ""
    @State private var password: String = ""
    @State private var confirmPassword: String = ""

    var body: some View {
        VStack(spacing: 20) {
            // Título
            Text("Crear Cuenta")
                .font(.largeTitle)
                .fontWeight(.bold)
                .padding(.bottom, 30)

            // Campo de Email
            TextField("Email", text: $email)
                .textInputAutocapitalization(.never)
                .keyboardType(.emailAddress)
                .padding()
                .background(Color(.systemGray6))
                .cornerRadius(10)

            // Campo de Contraseña
            SecureField("Contraseña", text: $password)
                .padding()
                .background(Color(.systemGray6))
                .cornerRadius(10)

            // Campo de Confirmar Contraseña
            SecureField("Confirmar Contraseña", text: $confirmPassword)
                .padding()
                .background(Color(.systemGray6))
                .cornerRadius(10)

            // Botón de Registro
            Button(action: {
                // Aquí irá la funcionalidad de registro
                print("Registrar usuario")
            }) {
                Text("Registrarse")
                    .fontWeight(.semibold)
                    .foregroundColor(.white)
                    .frame(maxWidth: .infinity)
                    .padding()
                    .background(Color.blue)
                    .cornerRadius(10)
            }
            .padding(.top, 20)

            Spacer()
        }
        .padding(.horizontal, 30)
        .padding(.top, 50)
    }
}

¿Qué hace este código?

Estados locales (@State): – email: Almacena el email del usuario – password: Almacena la contraseña – confirmPassword: Almacena la confirmación de contraseña

Elementos de la interfaz: – TextField para el email (con teclado de email y sin autocapitalización) – SecureField para las contraseñas (oculta el texto) – Button que por ahora solo imprime en consola

Diseño: – Usamos VStack con spacing de 20 puntos – Fondo gris claro para los campos – Bordes redondeados de 10 puntos – Botón azul que ocupa todo el ancho

Paso 2: Mostrando la vista

Ahora actualizamos ContentView.swift para mostrar nuestra vista de registro:

import SwiftUI

struct ContentView: View {
    var body: some View {
        RegisterView()
    }
}

Simple y directo. Por ahora, ContentView solo muestra la vista de registro.

Resultado hasta ahora

Si ejecutas la aplicación en el simulador, verás una pantalla limpia con: – Un título “Crear Cuenta” – Campo para ingresar email – Campo para ingresar contraseña – Campo para confirmar contraseña – Botón de “Registrarse”

El botón todavía no hace nada, solo imprime en consola. Eso es exactamente lo que queremos por ahora.

Paso 3: Configurando AWS Cognito User Pool

Ahora que tenemos nuestra interfaz lista, necesitamos crear el “backend” donde se almacenarán nuestros usuarios. Para esto usaremos AWS Cognito User Pool.

3.1 Acceder a la consola de AWS Cognito

  1. Ve a https://console.aws.amazon.com/
  2. Inicia sesión con tu cuenta de AWS
  3. En la barra de búsqueda superior, escribe “Cognito”
  4. Haz click en “Amazon Cognito”

3.2 Crear un nuevo User Pool

  • En la pantalla principal de Cognito, haz click en “Crear pool de usuarios” (o “Create user pool”)

AWS Cognito te mostrará diferentes opciones según el tipo de aplicación que vayas a desarrollar. Esto facilita la configuración al tener plantillas predefinidas.

  • Verás 4 opciones de tipo de aplicación:
    • Aplicación web tradicional
    • Aplicación de una sola página
    • Aplicación móvil ← Selecciona esta
    • Aplicación máquina a máquina
  • Selecciona “Aplicación móvil”

¿Por qué esta opción? Esta plantilla configura automáticamente el User Pool con los ajustes correctos para aplicaciones móviles, como no generar un “client secret” (que es importante para la seguridad en apps móviles nativas).

3.3 Configurar el nombre de la aplicación

  1. En el campo de nombre, ingresa un nombre para tu aplicación
    1. Por ejemplo: ios-tutorial-sgdgjz
    1. Puedes usar cualquier nombre, pero hazlo descriptivo
  2. Haz click en “Siguiente” o “Next”

3.4 Configurar opciones de autenticación

Ahora AWS te preguntará cómo quieres que los usuarios inicien sesión. Verás tres opciones:

  • Correo electrónico
  • Número de teléfono
  • Nombre de usuario

Para este tutorial, selecciona solo: – ✅ Correo electrónico – ❌ Número de teléfono (desmarcado) – ❌ Nombre de usuario (desmarcado)

¿Por qué solo email? Es la forma más común y simple de autenticación. Los usuarios se registrarán e iniciarán sesión usando su dirección de email. Mantengamos las cosas simples para empezar.

3.5 Configurar auto registro

En esta misma pantalla o en la siguiente, verás opciones de auto registro:

  1. Habilitar registro automático: ✅ Sí, habilítalo
    1. Esto permite que cualquier persona pueda crear una cuenta en tu app
    1. Sin esto, solo un administrador podría crear usuarios
  2. Atributos necesarios para el inicio de sesión:
    1. Solo necesitas el correo electrónico por ahora
    1. No agregues atributos adicionales (nombre, apellido, etc.)
    1. Mantener solo el email hace el proceso más simple

¿Por qué no pedir más información? Para empezar, solo el email es suficiente. Si en el futuro quieres pedir nombre, apellido, fecha de nacimiento, etc., puedes hacerlo. Pero para este tutorial, menos es más.

3.6 URL de retorno (opcional)

Es posible que veas una opción que dice “Agregar una URL de retorno” (opcional).

  • Déjala vacía / Sáltala

¿Para qué sirve? Esta opción es para OAuth flows o cuando usas Hosted UI (la interfaz web que provee Cognito). Como estamos haciendo autenticación nativa en la app móvil, no la necesitamos.

3.7 Confirmación de creación

  1. Haz click en “Crear” o “Create”
  2. Verás un mensaje de confirmación:
  3. La aplicación «ios-tutorial-sgdgjz» y su grupo de usuarios
    «User pool – sgdgjz» se han creado correctamente.
  4. AWS te llevará a una página que dice “Configure los recursos de su aplicación”

¡Perfecto! Tu User Pool ya está creado y listo para usar.

Nota importante: AWS te mostrará una opción que dice “Selecciona una plataforma para ver la guía de configuración rápida”. Esta es una guía automática que AWS ofrece para ayudarte a configurar rápidamente tu aplicación en diferentes plataformas (iOS, Android, Web, etc.).

Puedes consultarla si quieres ver la documentación oficial de AWS, pero en este artículo te guiaremos paso a paso con más detalles y explicaciones para que entiendas exactamente qué estamos haciendo y por qué.

3.8 ¿Qué acabamos de crear?

En este paso creamos:

  1. Un User Pool: El “contenedor” donde se almacenarán todos tus usuarios
  2. Una aplicación cliente: La configuración que permite a tu app iOS conectarse a ese User Pool
  3. Configuración de autenticación: Definimos que usaremos email para login y permitimos auto-registro

3.9 Obtener los datos de configuración

Ahora necesitamos obtener tres datos importantes del User Pool que usaremos en nuestro código iOS.

3.9.1 Obtener el Pool ID y Region

  1. En la consola de AWS Cognito, ve al menú lateral izquierdo y haz click en “User pools”
  2. Haz click en tu User Pool (el que acabas de crear)
  3. Verás la página de “Información del grupo de usuarios”

Aquí encontrarás:

  • Nombre del grupo de usuarios: User pool – sgdgjz
  • ID de grupo de usuarios (Pool ID): us-east-1_AbCd12345 (Reemplázalo por el tuyo)

Formato del Pool ID: El Pool ID tiene este formato: {region}_{identificador}

Por ejemplo: us-east-1_AbCd12345 – Region: us-east-1 (la parte antes del guion bajo) – Identificador: AbCd12345 (la parte después del guion bajo)

Copia y guarda tu Pool ID, lo necesitaremos en el código.

3.9.2 Obtener el Client ID

  1. En la misma página del User Pool, busca la pestaña “Integración de aplicaciones” (App integration) en la parte superior
  2. Haz click en esa pestaña
  3. Scroll hacia abajo hasta ver la sección “Clientes de aplicación” (App clients)
  4. Verás tu cliente listado (ejemplo: “ios tutorial- sgdgjz”)
  5. Haz click en el nombre del cliente
  6. Verás el Client ID

Formato del Client ID: Es un string largo de letras y números sin guiones, algo como: a1b2c3d4e5f6g7h8i9j0k1l2m3 (Reemplázalo por el tuyo)

Copia y guarda tu Client ID, lo necesitaremos en el código.

3.9.3 Resumen de datos necesarios

Al final, debes tener estos tres datos:

Region:    us-east-1                        (Reemplázalo por el tuyo)
Pool ID:   us-east-1_AbCd12345              (Reemplázalo por el tuyo)
Client ID: a1b2c3d4e5f6g7h8i9j0k1l2m3       (Reemplázalo por el tuyo)

IMPORTANTE: Los valores mostrados arriba son ejemplos ficticios. Tus valores reales serán diferentes. No compartas públicamente estos datos ya que son credenciales de acceso a tu User Pool.

Guarda estos tres datos en un lugar seguro (puedes anotarlos en un archivo de notas, pero no los subas a GitHub ni los compartas públicamente).

Paso 4: Entendiendo las dos formas de integrar Cognito en iOS

Antes de instalar el SDK, es importante entender que existen dos formas principales de integrar AWS Cognito en una aplicación iOS. AWS te mostrará ambas opciones, y es crucial saber cuál necesitas para evitar confusiones.

4.1 Opción 1: Hosted UI con OAuth (AppAuth)

¿Qué es? Hosted UI es una interfaz web pre-construida que AWS proporciona para autenticación. Cuando un usuario quiere iniciar sesión, tu app abre una página web (dentro de un Safari View Controller) donde el usuario ingresa sus credenciales.

¿Cómo funciona? 1. Tu app abre una página web de AWS 2. El usuario ingresa email y contraseña en esa página web 3. AWS maneja la autenticación 4. La página web redirige de vuelta a tu app con un código 5. Tu app intercambia ese código por tokens

Requiere: – URLs de callback (redirect URIs) – URLs de logout – Librería AppAuth-iOS – Carthage o CocoaPods para instalar AppAuth – Configuración de OAuth/OpenID Connect

Ventajas: – No tienes que crear UI de login (AWS te la da) – AWS maneja la seguridad de la página de login – Fácil integrar login social (Google, Facebook, Apple) con un solo flujo

Desventajas: – La UI de login es una página web, no nativa – Menos control sobre el diseño y la experiencia – Requiere configuración adicional de URLs – El usuario ve que sale de tu app momentáneamente

¿Cuándo usarlo? – Cuando quieres una solución rápida sin diseñar UI – Cuando priorizas que AWS maneje toda la seguridad del login – Cuando necesitas muchos proveedores sociales (Google, Facebook, etc.)

4.2 Opción 2: SDK Nativo de AWS Cognito (lo que usaremos)

¿Qué es? El SDK nativo te permite comunicarte directamente con AWS Cognito desde tu código Swift. Tú creas la interfaz de usuario (los TextFields, botones, etc.) y el SDK se encarga de enviar las peticiones a Cognito.

¿Cómo funciona? 1. El usuario ingresa email y contraseña en TU interfaz (que creaste en SwiftUI/UIKit) 2. Tu código llama a métodos del SDK: signUp(), signIn(), etc. 3. El SDK se comunica directamente con los servidores de Cognito 4. Cognito responde con tokens o errores 5. Tu código maneja la respuesta

Requiere: – SDK de AWS Cognito para iOS (AWSCognitoIdentityProvider) – Swift Package Manager o CocoaPods – Crear tu propia UI de login – Manejar los flujos de registro, login, confirmación, etc.

Ventajas: – Control total sobre la UI y experiencia de usuario – Interfaz 100% nativa (SwiftUI o UIKit) – No sales de tu app en ningún momento – Más control sobre el flujo de autenticación – Entiendes exactamente qué está pasando en cada paso

Desventajas: – Tienes que crear tu propia UI de login – Más código que escribir – Tú manejas los flujos de autenticación

¿Cuándo usarlo? – Cuando quieres control total sobre la UI – Cuando quieres una experiencia 100% nativa – Cuando quieres aprender cómo funciona Cognito por dentro – Cuando tu app tiene un diseño personalizado que no se puede lograr con Hosted UI

4.3 ¿Cuál usaremos en este tutorial?

Usaremos el SDK Nativo de AWS Cognito (Opción 2).

¿Por qué?

  1. Aprendizaje profundo: Entenderás exactamente cómo funciona Cognito, no solo “conectar y listo”
  2. Control total: Ya creamos nuestra interfaz bonita en SwiftUI, ¿para qué usar una página web?
  3. Experiencia nativa: La app se siente más profesional y pulida
  4. Flexibilidad: Puedes personalizar cada aspecto del flujo de autenticación
  5. Base sólida: Una vez que entiendas el SDK nativo, Hosted UI será trivial si lo necesitas

4.4 Importante: No confundas las guías de AWS

Cuando vayas a la documentación de AWS o veas las guías de configuración rápida, verás que AWS te muestra pasos para ambas opciones:

Si ves instrucciones que mencionan: – ❌ AppAuth-iOS – ❌ Carthage – ❌ URLs de callback/redirect – ❌ Hosted UI – ❌ OAuth flows

→ Esas son para la Opción 1 (Hosted UI), NO las sigas.

Lo que nosotros necesitamos: – ✅ AWSCognitoIdentityProvider – ✅ Swift Package Manager (o CocoaPods) – ✅ Pool ID y Client ID (que ya tenemos) – ✅ Métodos como signUp(), signIn(), confirmSignUp()

En el siguiente paso, instalaremos el SDK nativo correcto para iOS.

Paso 5: Instalando el SDK de AWS Cognito en nuestro proyecto

Ahora que tenemos claro que usaremos el SDK nativo, necesitamos instalarlo en nuestro proyecto de Xcode. Existen dos formas principales de hacerlo:

5.1 Opciones de instalación

Opción A: Swift Package Manager (SPM) – Integrado directamente en Xcode – No requiere instalación de herramientas adicionales – Más moderno y recomendado por Apple – Gestión de dependencias simple – Recomendado para proyectos nuevos

Opción B: CocoaPods – Herramienta de terceros para gestión de dependencias – Requiere instalar CocoaPods primero (usando Ruby) – Más tradicional, usado en proyectos legacy – Crea archivos .xcworkspace

¿Cuál usaremos?

Usaremos Swift Package Manager (Opción A) porque: 1. Ya está integrado en Xcode, no necesitas instalar nada extra 2. Es la forma moderna y recomendada 3. Es más simple de configurar 4. Apple lo soporta oficialmente

Si ya tienes un proyecto que usa CocoaPods, puedes seguir usándolo. Pero para este tutorial, Swift Package Manager es la mejor opción.

5.2 Instalando el SDK usando Swift Package Manager

Nota importante sobre los SDKs de AWS: AWS tiene dos SDKs para iOS: 1. SDK clásico (Objective-C/Swift): El tradicional, solo se instala con CocoaPods 2. Nuevo AWS SDK for Swift: Moderno, 100% Swift, soporta SPM nativamente

Usaremos el nuevo AWS SDK for Swift porque: – Soporta Swift Package Manager de forma nativa – Es 100% Swift (mejor integración con SwiftUI) – Es la dirección que AWS está tomando hacia el futuro – APIs más modernas y tipo-seguras

5.2.1 Agregar el paquete en Xcode

  1. Abre tu proyecto en Xcode
  2. Ve al menú: File → Add Package Dependencies…
  3. En la barra de búsqueda que aparece arriba, pega esta URL:
  4. https://github.com/awslabs/aws-sdk-swift
  5. Presiona Enter

5.2.2 Autenticación con GitHub (importante)

En este punto, Xcode te pedirá que te autentiques con GitHub y que generes un Personal Access Token (Token de acceso personal).

¿Por qué necesitas esto? El SDK de AWS para iOS está alojado en GitHub. Xcode necesita permiso para acceder y descargar el paquete de ese repositorio.

Pasos para crear el token:

  1. Inicia sesión en GitHub si aún no lo has hecho en Xcode
  2. Ve a GitHub.com y en tu perfil, ve a: Settings → Developer settings → Personal access tokens → Tokens (classic)
    1. O usa este link directo: https://github.com/settings/tokens
  3. Click en “Generate new token” → “Generate new token (classic)”
  4. Dale un nombre descriptivo al token, por ejemplo: Xcode AWS SDK Access
  5. Selecciona los siguientes permisos (scopes):
    • ✅ repo (Full control of private repositories)
    • ✅ admin:public_key (Full control of user public keys)
    • ✅ write:discussion (Read and write team discussions)
    • ✅ user (Update all user data)

¿Por qué estos permisos? Xcode los requiere para poder: – Acceder a repositorios (repo) – Gestionar claves públicas si es necesario (admin:public_key) – Acceder a discusiones del repositorio (write:discussion) – Verificar tu identidad de usuario (user)

  • Scroll hasta abajo y click en “Generate token”
  • Copia el token inmediatamente (solo se muestra una vez)
  • Pégalo en Xcode cuando te lo pida

IMPORTANTE: Guarda este token en un lugar seguro (como un administrador de contraseñas). No lo compartas públicamente ni lo subas a GitHub.

Una vez autenticado, Xcode podrá descargar el paquete del SDK.

5.2.3 Seleccionar el paquete de Cognito

Después de autenticarte, Xcode te mostrará una lista con muchos paquetes (productos) del AWS SDK. Esto es porque AWS tiene servicios para todo: S3, DynamoDB, Lambda, Cognito, etc.

Para nuestro proyecto, solo necesitamos: – ✅ AWSCognitoIdentityProvider

Pasos: 1. En la lista de paquetes, busca y selecciona AWSCognitoIdentityProvider 2. En “Add to target”, selecciona tu target principal: CognitoAuthDemo (o el nombre de tu proyecto) 3. Click en “Add Package”

Xcode comenzará a descargar e instalar el paquete junto con sus dependencias. Esto puede tomar 1-2 minutos dependiendo de tu conexión a internet.

5.2.4 Verificar la instalación

Una vez que Xcode termine de instalar: 1. Ve al Project Navigator (panel izquierdo) 2. Deberías ver una nueva sección llamada “Package Dependencies” 3. Dentro verás aws-sdk-swift listado

¡Perfecto! El SDK de AWS Cognito ya está instalado y listo para usar.

Paso 6: Implementando la funcionalidad de registro

Ahora que tenemos el SDK instalado, vamos a conectar nuestra interfaz con AWS Cognito para registrar usuarios reales.

6.1 Crear el servicio de autenticación

Primero, vamos a crear un archivo que maneje toda la comunicación con AWS Cognito. Esto nos permite mantener el código organizado y separar la lógica de autenticación de la interfaz.

Crea un nuevo archivo Swift llamado CognitoAuthService.swift:

import Foundation
import AWSCognitoIdentityProvider
import AWSClientRuntime

class CognitoAuthService {

    // MARK: - Configuración
    // Reemplaza estos valores con los tuyos del User Pool
    private let region = "us-east-1"  // Tu región real
    private let userPoolId = "us-east-1_NmaGmKWMF"  // Tu Pool ID real (Reemplázalo por el tuyo)
    private let clientId = "38bdoa9oeelm5pcd2slntqnkfj"  // Tu Client ID real (Reemplázalo por el tuyo)

    private var cognitoClient: CognitoIdentityProviderClient?

    init() {
        // Inicializar el cliente de Cognito
        Task {
            do {
                self.cognitoClient = try await CognitoIdentityProviderClient(region: region)
            } catch {
                print("Error al inicializar Cognito Client: \(error)")
            }
        }
    }

    // MARK: - Registro de Usuario
    func signUp(email: String, password: String) async throws -> String {
        guard let client = cognitoClient else {
            throw NSError(domain: "CognitoAuthService", code: -1,
                         userInfo: [NSLocalizedDescriptionKey: "Cliente de Cognito no inicializado"])
        }

        // Crear los atributos del usuario
        let emailAttribute = CognitoIdentityProviderClientTypes.AttributeType(
            name: "email",
            value: email
        )

        // Crear la solicitud de registro
        let signUpInput = SignUpInput(
            clientId: clientId,
            password: password,
            userAttributes: [emailAttribute],
            username: email
        )

        do {
            let response = try await client.signUp(input: signUpInput)

            print("✅ Usuario registrado exitosamente")
            print("User Sub: \(response.userSub ?? "N/A")")
            print("¿Confirmado?: \(response.userConfirmed)")

            if response.userConfirmed {
                return "Usuario registrado y confirmado automáticamente"
            } else {
                return "Usuario registrado. Revisa tu email para el código de confirmación"
            }

        } catch {
            // Manejar errores de Cognito
            print("❌ Error al registrar: \(error)")
            throw NSError(domain: "CognitoAuthService", code: 1000,
                         userInfo: [NSLocalizedDescriptionKey: "Error al registrar: \(error.localizedDescription)"])
        }
    }
}

¿Qué hace este código?

  1. Configuración: Define la región, Pool ID y Client ID (tus credenciales de AWS)
  2. Inicialización: Crea el cliente de Cognito cuando se instancia la clase
  3. signUp(): Método asíncrono que registra un nuevo usuario
    1. Recibe email y contraseña
    1. Crea un atributo de email (Cognito lo usará para enviar el código de confirmación)
    1. Envía la solicitud a AWS Cognito
    1. Retorna un mensaje de éxito o lanza un error

Importante: Reemplaza los valores de region, userPoolId y clientId con los tuyos reales que obtuviste en el Paso 3.

6.2 Actualizar la vista de registro

Ahora vamos a actualizar RegisterView.swift para usar nuestro servicio de autenticación. Reemplaza el contenido completo del archivo con:

import SwiftUI

struct RegisterView: View {
    @State private var email: String = ""
    @State private var password: String = ""
    @State private var confirmPassword: String = ""
    @State private var isLoading: Bool = false
    @State private var message: String = ""
    @State private var showAlert: Bool = false

    private let authService = CognitoAuthService()

    var body: some View {
        VStack(spacing: 20) {
            // Título
            Text("Crear Cuenta")
                .font(.largeTitle)
                .fontWeight(.bold)
                .padding(.bottom, 30)

            // Campo de Email
            TextField("Email", text: $email)
                .textInputAutocapitalization(.never)
                .keyboardType(.emailAddress)
                .padding()
                .background(Color(.systemGray6))
                .cornerRadius(10)
                .disabled(isLoading)

            // Campo de Contraseña
            SecureField("Contraseña", text: $password)
                .padding()
                .background(Color(.systemGray6))
                .cornerRadius(10)
                .disabled(isLoading)

            // Campo de Confirmar Contraseña
            SecureField("Confirmar Contraseña", text: $confirmPassword)
                .padding()
                .background(Color(.systemGray6))
                .cornerRadius(10)
                .disabled(isLoading)

            // Mostrar mensaje si existe
            if !message.isEmpty {
                Text(message)
                    .font(.caption)
                    .foregroundColor(.gray)
                    .multilineTextAlignment(.center)
                    .padding(.horizontal)
            }

            // Botón de Registro
            Button(action: {
                registerUser()
            }) {
                if isLoading {
                    ProgressView()
                        .progressViewStyle(CircularProgressViewStyle(tint: .white))
                        .frame(maxWidth: .infinity)
                        .padding()
                } else {
                    Text("Registrarse")
                        .fontWeight(.semibold)
                        .foregroundColor(.white)
                        .frame(maxWidth: .infinity)
                        .padding()
                }
            }
            .background(isLoading ? Color.gray : Color.blue)
            .cornerRadius(10)
            .disabled(isLoading)
            .padding(.top, 20)

            Spacer()
        }
        .padding(.horizontal, 30)
        .padding(.top, 50)
        .alert("Registro", isPresented: $showAlert) {
            Button("OK", role: .cancel) { }
        } message: {
            Text(message)
        }
    }

    // MARK: - Función de Registro
    private func registerUser() {
        // Validaciones básicas
        guard !email.isEmpty, !password.isEmpty, !confirmPassword.isEmpty else {
            message = "Por favor completa todos los campos"
            showAlert = true
            return
        }

        guard password == confirmPassword else {
            message = "Las contraseñas no coinciden"
            showAlert = true
            return
        }

        guard password.count >= 8 else {
            message = "La contraseña debe tener al menos 8 caracteres"
            showAlert = true
            return
        }

        // Iniciar proceso de registro
        isLoading = true
        message = "Registrando usuario..."

        Task {
            do {
                let result = try await authService.signUp(email: email, password: password)

                await MainActor.run {
                    isLoading = false
                    message = result
                    showAlert = true

                    // Limpiar campos si fue exitoso
                    email = ""
                    password = ""
                    confirmPassword = ""
                }
            } catch {
                await MainActor.run {
                    isLoading = false
                    message = error.localizedDescription
                    showAlert = true
                }
            }
        }
    }
}

¿Qué agregamos?

  1. Estados adicionales:
    • isLoading: Para mostrar el indicador de carga
    • message: Para mostrar mensajes al usuario
    • showAlert: Para controlar cuándo mostrar la alerta
  2. Instancia del servicio:
    • authService = CognitoAuthService(): Crea una instancia del servicio
  3. Validaciones en registerUser():
    • Verifica que los campos no estén vacíos
    • Verifica que las contraseñas coincidan
    • Verifica longitud mínima de contraseña
  4. Llamada asíncrona:
    • Usa Task para hacer la llamada asíncrona
    • Muestra spinner mientras carga
    • Muestra alerta con el resultado
    • Limpia los campos si fue exitoso
  5. UI mejorada:
    • Deshabilita campos mientras carga
    • Muestra spinner en el botón

Importante: AWS Cognito por defecto requiere que las contraseñas cumplan con ciertos requisitos de seguridad:

6.3 Requisitos de contraseña en AWS Cognito

  • ✅ Mínimo 8 caracteres
  • ✅ Al menos un número
  • ✅ Al menos una letra mayúscula
  • ✅ Al menos una letra minúscula
  • ✅ Al menos un carácter especial (!, @, #, $, %, etc.)

Ejemplo de contraseña válida: 1@wAs1234

Si intentas registrarte con una contraseña que no cumple estos requisitos, Cognito rechazará el registro con un error de “contraseña inválida”.

Nota: Estos requisitos se configuran en el User Pool de AWS Cognito. Puedes modificarlos en la consola de AWS, pero por defecto vienen así para mayor seguridad.

6.4 Probando el registro

  1. Ejecuta la app en el simulador (Cmd + R)
  2. Ingresa tu email real (para recibir el código de confirmación)
  3. Ingresa una contraseña que cumpla los requisitos, por ejemplo: 1@wAs1234
  4. Confirma la contraseña
  5. Click en “Registrarse”

¿Qué debería pasar?

  • Verás un spinner mientras se procesa
  • Si todo funciona, verás una alerta: “Usuario registrado. Revisa tu email para el código de confirmación”
  • Recibirás un email de AWS Cognito con un código de 6 dígitos
  • Los campos se limpiarán automáticamente

6.5 Verificar el usuario en AWS

Para confirmar que el usuario se registró correctamente:

  1. Ve a la consola de AWS Cognito
  2. Abre tu User Pool
  3. Ve a la sección “Users” en el menú lateral
  4. Deberías ver tu usuario listado con:
    1. Username: Tu email
    1. Account status: UNCONFIRMED (porque aún no has ingresado el código)
    1. Email verified: No

En el siguiente artículo implementaremos la confirmación del código para activar la cuenta.

Conclusión

En este artículo logramos:

  1. ✅ Crear una interfaz de registro en SwiftUI
  2. ✅ Configurar AWS Cognito User Pool desde la consola
  3. ✅ Entender las dos formas de integrar Cognito (Hosted UI vs SDK Nativo)
  4. ✅ Instalar AWS SDK for Swift usando Swift Package Manager
  5. ✅ Implementar registro de usuarios que se conecta con Cognito
  6. ✅ Probar el registro y recibir el email de confirmación

¿Qué sigue?

En los siguientes artículos vamos a: Implementar la confirmación del código de verificación – Crear una pantalla para ingresar el código que recibiste por email – Activar la cuenta del usuario en Cognito – Manejar casos de error (código inválido, expirado, etc.)

Por ahora, ya tienes una app funcional que registra usuarios en AWS Cognito. El usuario recibe su código por email, y está listo para confirmarlo.

Recuerda: Los valores de Pool ID y Client ID en el código son ejemplos. Asegúrate de usar tus propias credenciales de AWS Cognito.

⚠️ Nota importante sobre validaciones

En este artículo (y en toda la serie), nuestro enfoque principal es aprender a integrar y usar AWS Cognito, no implementar todas las mejores prácticas de desarrollo iOS. Por esta razón:

  • No implementaremos validaciones exhaustivas de formato de email (regex complejos, verificación de dominio, etc.)
  • No agregaremos validaciones avanzadas de contraseña más allá de lo básico (longitud, caracteres especiales, etc.)
  • No implementaremos manejo de errores elaborado con mensajes personalizados para cada caso
  • No usaremos arquitecturas complejas (MVVM, VIPER, Clean Architecture)

Esto no significa que estas validaciones no sean importantes. En una aplicación de producción, deberías implementarlas. Simplemente las omitimos aquí para no desviar el foco de nuestro objetivo: entender cómo funciona AWS Cognito y cómo integrarlo correctamente.

Si quieres aprender sobre validaciones, arquitecturas y mejores prácticas de iOS, hay excelentes recursos dedicados a esos temas. Aquí nos concentramos 100% en AWS.

Reflexión final

En este proyecto, nuestro objetivo fue crear una implementación sencilla de registro de usuarios en iOS utilizando AWS Cognito SDK nativo. Desde la configuración de AWS Cognito hasta la integración con nuestra aplicación SwiftUI, seguimos un enfoque paso a paso para que cualquier desarrollador pueda realizar su primer registro y autenticación sin complicaciones.

Sabemos que este es solo el comienzo. Más adelante, iremos incorporando ajustes y mejoras, explorando características adicionales que AWS nos ofrece para el desarrollo móvil. Si tienes sugerencias sobre temas que te gustaría ver en los próximos artículos, serán bienvenidas.

Además, este mismo proyecto servirá como base para aprender e integrar nuevas funcionalidades, como: – Confirmación de código de verificación – Inicio de sesión (Sign In) – Recuperación de contraseña – Autenticación multifactor (MFA) – Autenticación con redes sociales (Google, Facebook, Apple Sign In) – Autorización con roles y grupos de usuarios – Persistencia de sesión y tokens – Y mucho más…

¡Mantente atento a próximas actualizaciones! Muy pronto estaremos ampliando el desarrollo móvil con AWS y llevando esta integración al siguiente nivel.

Bueno, mi nombre es José Luján, desarrollador con 20 años de experiencia trabajando como desarrollador, manager y explorando el mundo del desarrollo mobile, IA y crypto. Este fue solo el primer paso en la integración de AWS con iOS, pero aún hay mucho más por descubrir. Seguiremos explorando nuevas herramientas, optimizando nuestro código y llevando nuestras apps al siguiente nivel.

Nos vemos pronto en el siguiente artículo, y si quieres seguir en contacto o tienes alguna sugerencia de tema, me puedes encontrar en cualquier red social como @josedlujan. 🚀

¡Hasta la próxima!

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *