스프링 부트 백엔드 개발 강좌, OAuth2로 로그인 로그아웃 구현, 스프링 시큐리티로 OAuth2를 구현하고 적용하기

1. 서론

현대 애플리케이션의 인증(Authentication) 및 인가(Authorization) 메커니즘은 매우 중요합니다. OAuth2는
다양한 플랫폼에서 인증 및 인가를 처리하기 위한 널리 사용되는 프레임워크입니다. 본 강좌에서는 스프링 부트
와 스프링 시큐리티를 사용하여 OAuth2를 통한 로그인 및 로그아웃 과정을 단계별로 설명하겠습니다. 목표는
사용자 인증 기능을 포함한 안전한 API를 구축하는 것입니다.

2. 스프링 부트 및 스프링 시큐리티 프로젝트 설정

2.1. 설치 요구 사항

본 강좌를 진행하기 위해서는 다음의 소프트웨어가 필요합니다:

  • JDK 11 이상
  • Apache Maven
  • IDE (IntelliJ IDEA, Eclipse 등)

2.2. 프로젝트 생성

먼저, Spring Initializr를 사용하여 새로운 스프링 부트 프로젝트를 생성합니다. 의존성으로는
Spring Web, Spring Security, OAuth2 Client를 추가합니다.

mvn clean install

3. OAuth2 인증 설정

3.1. OAuth2 제공자 구성

다양한 OAuth2 제공자가 있으며, 이번 강좌에서는 Google OAuth2를 사용할 것입니다. Google Cloud Console에서
새로운 프로젝트를 생성하고 OAuth 2.0 클라이언트 ID를 생성합니다.
필요한 정보는 클라이언트 ID와 클라이언트 비밀입니다.

3.2. 애플리케이션 프로퍼티 설정

src/main/resources/application.yml 파일에 다음과 같은 설정을 추가합니다:

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: YOUR_CLIENT_ID
            client-secret: YOUR_CLIENT_SECRET
            scope:
              - profile
              - email
            redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
        provider:
          google:
            authorization-uri: https://accounts.google.com/o/oauth2/auth
            token-uri: https://oauth2.googleapis.com/token
            user-info-uri: https://www.googleapis.com/userinfo/email
            user-name-attribute: email

4. 스프링 시큐리티 설정

4.1. 시큐리티 설정 클래스 생성

스프링 시큐리티의 기본 설정을 위해 SecurityConfig라는 클래스를 생성합니다. 이 클래스는
WebSecurityConfigurerAdapter를 확장하여 시큐리티 구성을 정의합니다.

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/", "/login", "/oauth2/**").permitAll() // 로그인과 관련된 경로는 모든 사용자에게 허용
            .anyRequest().authenticated() // 그 외의 요청은 인증된 사용자만 접근 가능
            .and()
            .oauth2Login(); // OAuth2 로그인 설정
    }
}

5. 로그인 및 로그아웃

5.1. 로그인 처리

OAuth2 로그인 처리는 스프링 시큐리티가 자동으로 관리합니다. 사용자가 /login 경로로 접근하면 로그인 페이지를
제공하고, 로그인 후에는 Redirect URI로 설정한 경로로 리다이렉트 됩니다.

5.2. 로그아웃 처리

로그아웃은 logout 경로를 설정하여 간단하게 처리할 수 있습니다. 로그아웃 후 사용자를
홈 페이지로 리다이렉트 할 수 있습니다.

http.logout()
        .logoutSuccessUrl("/") // 로그아웃 시 홈으로 리다이렉트
        .invalidateHttpSession(true); // 세션 무효화

6. 클라이언트 애플리케이션 생성

로그인과 로그아웃을 테스트하기 위해 간단한 클라이언트 애플리케이션을 생성합니다. 사용자는 Google
계정을 통해 인증한 후 본인 정보를 확인할 수 있습니다.

import org.springframework.security.oauth2.client.registration.ClientRegistrationRepository;
import org.springframework.security.oauth2.client.web.userdetails.OAuth2UserService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    private final OAuth2UserService oAuth2UserService;
    private final ClientRegistrationRepository clientRegistrationRepository;

    public UserController(OAuth2UserService oAuth2UserService, ClientRegistrationRepository clientRegistrationRepository) {
        this.oAuth2UserService = oAuth2UserService;
        this.clientRegistrationRepository = clientRegistrationRepository;
    }

    @GetMapping("/user")
    public String getUserInfo(Principal principal) {
        return "User Info: " + principal.getName(); // 사용자 정보 리턴
    }
}

7. 테스트 및 결론

모든 설정이 완료되었으면 애플리케이션을 실행하여
/login 페이지로 접속합니다. Google 로그인 버튼을 클릭하여 인증 과정이 올바르게 진행되는지 확인하세요.
로그인이 성공하면 /user 경로에서 사용자 정보를 확인할 수 있습니다.

이번 강좌를 통해 스프링 부트를 사용한 OAuth2 로그인/로그아웃 기초를 배웠습니다. 향후에는 JWT를
활용한 더 복잡한 인증 메커니즘으로 확장할 수 있으며, 회사의 요구 사항에 맞는 사용자 정의 기능을 추가할
수 있습니다.

© 2023 스프링 부트 개발 블로그

스프링 부트 백엔드 개발 강좌, OAuth2로 로그인 로그아웃 구현, 글 수정, 삭제, 글쓴이 확인 로직 추가하기

목차

  1. 소개
  2. 스프링 부트 소개
  3. OAuth2 개요
  4. 로그인/로그아웃 구현
  5. 글 수정 및 삭제 기능 구현
  6. 글쓴이 확인 로직 추가
  7. 결론

소개

오늘은 스프링 부트를 사용하여 백엔드 애플리케이션을 개발하는 방법을 알아보겠습니다. 이번 강좌에서는 OAuth2를 통한 로그인 및 로그아웃 구현 방법과 글 수정 및 삭제 기능, 그리고 글쓴이 확인 로직을 추가하는 방법을 다룰 것입니다. 이 과정을 통해 스프링 부트의 다양한 기능을 활용하는 방법을 배울 수 있습니다.

스프링 부트 소개

스프링 부트는 스프링 프레임워크를 기반으로 한 간편한 애플리케이션 개발을 지원하는 프레임워크입니다. 복잡한 설정 없이 빠르게 애플리케이션을 구축할 수 있도록 도와주며, 다양한 내장 서버(예: Tomcat, Jetty 등)를 지원합니다. 스프링 부트의 주요 이점은 다음과 같습니다:

  • 빠른 시작: 초기 설정이 간편하여 개발 시간을 단축할 수 있습니다.
  • 자동 구성: 필요한 라이브러리와 의존성을 자동으로 설정해줍니다.
  • 내장 서버: 별도의 서버 설정 없이 로컬에서 쉽게 애플리케이션을 실행할 수 있습니다.
  • 강력한 커뮤니티: 활발한 사용자와 풍부한 자료가 많아 학습과 문제 해결에 도움이 됩니다.

OAuth2 개요

OAuth2는 클라이언트 애플리케이션이 사용자 자원에 접근할 수 있도록 권한을 부여하는 인증 프로토콜입니다. OAuth2를 통해 사용자는 애플리케이션에 대한 접근 권한을 안전하게 관리할 수 있습니다. OAuth2는 여러 인증 방식(예: Authorization Code, Implicit, Resource Owner Password Credentials 등)을 지원하며, 일반적으로 웹 애플리케이션과 모바일 애플리케이션에서 많이 사용됩니다.

이번 강좌에서는 OAuth2를 사용하여 사용자 인증을 구현하고, 이 인증 정보를 가지고 글을 작성, 수정, 삭제하는 기능을 추가할 것입니다. 우리는 기본적으로 Authorization Code Grant 방식을 사용할 것입니다.

로그인/로그아웃 구현

스프링 부트 애플리케이션에 OAuth2 기반의 로그인/로그아웃 기능을 구현하는 방법을 살펴보겠습니다. 이 과정에서 스프링 시큐리티(Spring Security)를 사용하여 인증 및 권한 부여를 처리할 것입니다. 다음 단계로 진행해 보겠습니다.

1. 의존성 추가

우선, Maven pom.xml 파일에 필요한 의존성을 추가해야 합니다. 다음의 의존성을 추가하세요:


      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-security</artifactId>
      </dependency>
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-oauth2-client</artifactId>
      </dependency>
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
    

2. application.yml 설정

이제 oauth2 클라이언트 정보를 설정해야 합니다. src/main/resources/application.yml 파일에 다음과 같이 설정하세요:


    spring:
      security:
        oauth2:
          client:
            registration:
              google:
                client-id: YOUR_CLIENT_ID
                client-secret: YOUR_CLIENT_SECRET
                scope: profile, email
                redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
                authorization-grant-type: authorization_code
            provider:
              google:
                authorization-uri: https://accounts.google.com/o/oauth2/auth
                token-uri: https://oauth2.googleapis.com/token
                user-info-uri: https://www.googleapis.com/userinfo/v2/me
    

3. SecurityConfig 클래스 작성

안전한 애플리케이션 구성을 위해 SecurityConfig 클래스를 생성합니다. 이 클래스는 스프링 시큐리티의 보안 설정을 담당합니다.


    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

    @Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http
                .authorizeRequests()
                    .antMatchers("/", "/login", "/error/**").permitAll()
                    .anyRequest().authenticated()
                    .and()
                .oauth2Login()
                    .defaultSuccessUrl("/home", true)
                    .failureUrl("/login?error");
        }
    }
    

4. 로그인 및 로그아웃 컨트롤러 구현

사용자가 로그인을 시도할 때 호출되는 HomeController 클래스를 생성하여 로그인 후의 흐름을 처리합니다.


    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.GetMapping;

    @Controller
    public class HomeController {

        @GetMapping("/")
        public String index() {
            return "index"; // index.html 페이지로 리턴
        }

        @GetMapping("/home")
        public String home() {
            return "home"; // home.html 페이지로 리턴
        }
    }
    

여기까지 입력하면 기본 로그인 및 로그아웃 기능이 구현되었습니다. 이제 사용자가 Google 계정을 통해 로그인할 수 있습니다.

글 수정 및 삭제 기능 구현

이제 기본적인 로그인/로그아웃 기능을 구현했으니, 다음으로는 글 작성, 수정 및 삭제 기능을 추가하겠습니다.

1. 글 게시를 위한 엔티티 및 리포지토리 작성

먼저, Post 엔티티와 이를 위한 JPA 리포지토리를 생성합니다.


    import javax.persistence.*;
    import java.time.LocalDateTime;

    @Entity
    public class Post {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        
        private String title;
        private String content;

        @ManyToOne
        @JoinColumn(name="user_id")
        private User user; // 작성자 정보

        private LocalDateTime createdAt;
        private LocalDateTime updatedAt;

        // getters and setters
    }
    

    import org.springframework.data.jpa.repository.JpaRepository;

    public interface PostRepository extends JpaRepository {
    }
    

2. 글 작성 및 수정 기능 구현

컨트롤러를 작성하여 글 작성 및 수정 기능을 처리합니다.


    import org.springframework.security.core.annotation.AuthenticationPrincipal;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.*;

    @Controller
    @RequestMapping("/posts")
    public class PostController {

        private final PostRepository postRepository;

        public PostController(PostRepository postRepository) {
            this.postRepository = postRepository;
        }

        @GetMapping("/new")
        public String newPost(Model model) {
            model.addAttribute("post", new Post());
            return "newpost"; // 글 작성 페이지
        }

        @PostMapping
        public String createPost(@ModelAttribute Post post, @AuthenticationPrincipal User user) {
            post.setUser(user); // 현재 로그인한 사용자 설정
            post.setCreatedAt(LocalDateTime.now());
            postRepository.save(post);
            return "redirect:/posts";
        }

        @GetMapping("/{id}/edit")
        public String editPost(@PathVariable Long id, Model model) {
            Post post = postRepository.findById(id).orElseThrow();
            model.addAttribute("post", post);
            return "editpost"; // 글 수정 페이지
        }

        @PostMapping("/{id}")
        public String updatePost(@PathVariable Long id, @ModelAttribute Post post) {
            post.setId(id);
            post.setUpdatedAt(LocalDateTime.now());
            postRepository.save(post);
            return "redirect:/posts";
        }
    }
    

3. 글 삭제 기능 구현

글 삭제를 위한 메소드도 PostController에 추가합니다.


    @DeleteMapping("/{id}")
    public String deletePost(@PathVariable Long id) {
        postRepository.deleteById(id);
        return "redirect:/posts";
    }
    

글쓴이 확인 로직 추가

마지막으로, 글쓴이 확인 로직을 추가하여 사용자가 자신이 작성한 글만 수정 또는 삭제할 수 있도록 설정합니다. 이를 위해 사용자가 로그인했을 때, 해당 사용자의 정보와 글의 작성자를 비교하는 로직을 추가합니다.


    @PostMapping("/{id}/edit")
    public String editPost(@PathVariable Long id, @AuthenticationPrincipal User user) {
        Post post = postRepository.findById(id).orElseThrow();
        if (!post.getUser().equals(user)) {
            throw new AccessDeniedException("이 글은 수정할 수 없습니다."); // 접근 거부 예외
        }
        return "editpost"; // 수정 페이지로 이동
    }

    @DeleteMapping("/{id}")
    public String deletePost(@PathVariable Long id, @AuthenticationPrincipal User user) {
        Post post = postRepository.findById(id).orElseThrow();
        if (!post.getUser().equals(user)) {
            throw new AccessDeniedException("이 글은 삭제할 수 없습니다."); // 접근 거부 예외
        }
        postRepository.deleteById(id);
        return "redirect:/posts";
    }
    

결론

이번 강좌에서는 스프링 부트를 사용하여 OAuth2 기반의 로그인 및 로그아웃 기능을 구현하고, 글 작성, 수정, 삭제 기능을 추가하는 방법을 배웠습니다. 또한, 글쓴이 확인 로직을 통해 사용자가 자신의 글만 수정 또는 삭제할 수 있도록 하는 안전 장치를 마련했습니다. 이러한 과정을 통해 스프링 부트와 OAuth2의 기본적인 사용법을 익힐 수 있었으며, 실제 애플리케이션 개발에 필요한 기초 지식을 쌓을 수 있었습니다.

앞으로도 스프링 부트를 활용한 다양한 기능에 대해 학습하며, 더 나아가 실력이 향상되기를 바랍니다. 여러분의 개발 여정에 행운을 빕니다!

스프링 부트 백엔드 개발 강좌, OAuth2로 로그인 로그아웃 구현, OAuth란

안녕하세요! 이번 블로그 포스트에서는 스프링 부트를 사용하여 OAuth 2.0을 통해 안전하게 로그인 및 로그아웃 기능을 구현하는 방법을 알아보겠습니다. OAuth란 무엇인지부터 시작해 그 기본 개념을 이해한 후, 실제 코드 예제를 통해 스프링 부트에서 OAuth2를 사용하는 방법을 자세히 살펴보겠습니다.

1. OAuth란 무엇인가?

OAuth(오픈 인증)는 사용자가 자신의 정보를 제3의 서비스에 안전하게 공유할 수 있도록 허용하는 인증 프로토콜입니다. 예를 들어, 사용자가 서비스 A에서 자신의 정보를 서비스 B와 공유하고자 할 때, 서비스 A의 로그인 정보를 직접 제공하지 않고 서비스 B에 접근 권한을 부여할 수 있습니다.

1.1 OAuth의 배경

과거에는 사용자가 여러 서비스에 가입할 때마다 각각의 로그인 정보를 따로 관리해야 했습니다. 이는 보안상의 문제를 일으킬 수 있으며, 사용자의 번거로운 경험을 초래했습니다. OAuth는 이러한 문제를 해결하기 위해 설계된 프로토콜로, 토큰 기반 인증 및 권한 부여를 통해 더 안전한 방법으로 서로의 정보를 공유할 수 있게 합니다.

1.2 OAuth의 작동 원리

OAuth는 일반적으로 다음과 같은 과정을 통해 작동합니다:

  • 인증 요청: 클라이언트가 사용자를 대신하여 리소스 서버에 접근하기 위해 요청을 보냅니다.
  • 사용자 인증: 사용자 디스플레이에 로그인 화면이 표시되며, 사용자는 자신의 인증 정보를 입력합니다.
  • 토큰 발급: 사용자 인증이 성공하면 인증 서버는 클라이언트에 접근 토큰을 발급합니다.
  • 리소스 요청: 클라이언트는 발급받은 토큰을 사용하여 리소스 서버에 요청을 보냅니다.

2. OAuth 2.0의 주요 구성 요소

OAuth 2.0에는 다음과 같은 구성 요소가 있습니다:

  • 클라이언트(Client): 리소스에 접근하려는 애플리케이션입니다.
  • 리소스 서버(Resource Server): 보호된 데이터를 호스팅하는 서버입니다.
  • 인증 서버(Authorization Server): 클라이언트에게 인증 토큰을 발급하는 서버입니다.
  • 사용자(User): 클라이언트가 접근하려는 데이터의 소유자입니다.

3. 스프링 부트로 OAuth2 구현하기

이제 스프링 부트를 사용하여 OAuth2를 구현해 보겠습니다. 이 예제에서는 Google OAuth2를 사용하여 로그인과 로그아웃을 구현할 것입니다.

3.1 프로젝트 설정

스프링 부트 프로젝트를 생성하기 위해 Spring Initializr(https://start.spring.io/)를 사용합니다. 다음과 같은 종속성을 추가합니다:

  • Spring Web
  • Spring Security
  • Spring Boot DevTools
  • OAuth2 Client

3.2 application.yml 설정

프로젝트가 생성된 후, src/main/resources/application.yml 파일에 Google OAuth2 클라이언트 ID와 클라이언트 비밀번호를 설정합니다.

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: YOUR_CLIENT_ID
            client-secret: YOUR_CLIENT_SECRET
            scope: profile, email
            redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
        provider:
          google:
            authorization-uri: https://accounts.google.com/o/oauth2/auth
            token-uri: https://oauth2.googleapis.com/token
            user-info-uri: https://www.googleapis.com/oauth2/v3/userinfo
            user-info-authentication-method: header

3.3 WebSecurityConfigurerAdapter 설정

스프링 시큐리티를 설정하여 OAuth2 지원을 활성화합니다. WebSecurityConfigurerAdapter를 확장하고 필요한 구성을 정의합니다.

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/login").permitAll()
                .anyRequest().authenticated()
                .and()
            .oauth2Login()
                .loginPage("/login")
                .defaultSuccessUrl("/home", true);
    }
}

3.4 로그인 컨트롤러 추가

로그인 후 리디렉션할 컨트롤러를 추가합니다.

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {
    
    @GetMapping("/")
    public String index() {
        return "index"; // 인덱스 페이지 뷰 반환
    }

    @GetMapping("/home")
    public String home() {
        return "home"; // 홈 페이지 뷰 반환
    }
}

3.5 HTML 뷰 만들기

스프링 부트에서 사용할 두 개의 HTML 파일을 만듭니다. src/main/resources/templates/index.html 파일을 생성합니다.

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>OAuth 로그인</title>
</head>
<body>
    <h1>환영합니다!</h1>
    <a href="/oauth2/authorization/google">Google로 로그인</a>
</body>
</html>

다음으로 src/main/resources/templates/home.html 파일을 생성합니다.

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>홈</title>
</head>
<body>
    <h1>안녕하세요, <span th:text="${#authentication.details.name}"></span>!</h1>
    <a href="/logout">로그아웃</a>
</body>
</html>

3.6 애플리케이션 실행

프로젝트를 빌드하고 실행하면, 애플리케이션의 메인 페이지에서 Google 로그인 링크를 볼 수 있습니다. 이를 클릭하면 Google 로그인 페이지로 리디렉션되며, 로그인이 성공하면 홈 페이지로 돌아갑니다.

4. 마무리

이제 스프링 부트와 OAuth2를 사용하여 로그인 및 로그아웃 기능을 성공적으로 구현해보았습니다. OAuth2는 다양한 서비스 간에 안전하게 데이터 공유를 가능하게 하며, 이를 통해 더욱 향상된 사용자 경험을 제공할 수 있습니다. 또한, OAuth2의 다양한 기능을 활용하여 비즈니스 로직에 맞는 인증 방식을 선택할 수 있습니다.

더 많은 자료와 정보를 원하신다면, 스프링 부트 공식 문서와 OAuth2에 대한 다양한 자료를 참고하시기 바랍니다. 언제든지 댓글로 질문해 주시면, 제가 아는 한에서 최대한 도움을 드리도록 하겠습니다. 감사합니다!

스프링 부트 백엔드 개발 강좌, OAuth2로 로그인 로그아웃 구현, 권한 부여 코드 승인 타입이란

현대의 웹 애플리케이션에서는 보안과 사용자 인증이 매우 중요한 요소입니다. 특히 소셜 로그인, API 연동 등 다양한 방식으로 사용자 인증을 진행해야 하는 경우가 많습니다. 이때 많이 사용되는 프로토콜 중 하나가 바로 OAuth2입니다. 본 강좌에서는 스프링 부트를 이용하여 OAuth2를 통한 로그인 및 로그아웃 기능을 구현하고, 권한 부여 코드 승인 타입에 대해 자세히 알아보겠습니다.

1. OAuth2란?

OAuth2는 인터넷 사용자들이 비밀번호를 제공하지 않고도 제3자 애플리케이션이 자신들의 정보를 보도록 허용할 수 있게 해주는 인기 있는 인증 프로토콜입니다. 애플리케이션이 사용자의 정보를 안전하게 접근할 수 있도록 권한 위임을 가능하게 합니다.

2. OAuth2 프로세스 이해하기

OAuth2의 주요 프로세스는 다음과 같은 단계로 나뉩니다:

  • 1) 클라이언트 등록: 클라이언트 애플리케이션이 OAuth 제공자에게 등록되어 고유 클라이언트 ID와 비밀키를 발급받습니다.
  • 2) 인증 요청: 사용자가 클라이언트 애플리케이션에서 인증 버튼을 클릭하면, OAuth 서버로 인증 요청이 전달됩니다.
  • 3) 사용자 인증: OAuth 서버에서는 사용자가 인증을 수행하고, 권한을 부여하는 화면을 표시합니다.
  • 4) 권한 부여 코드 발급: 사용자가 권한을 부여하면 OAuth 서버는 클라이언트로 권한 부여 코드를 반환합니다.
  • 5) 액세스 토큰 발급: 클라이언트는 권한 부여 코드를 사용하여 액세스 토큰을 요청합니다.
  • 6) API 접근: 클라이언트는 액세스 토큰을 이용해 API에 접근하여 사용자의 데이터에 접근합니다.

3. 스프링 부트에서 OAuth2 설정하기

스프링 부트를 이용하여 OAuth2를 설정하는 과정은 다음과 같습니다. 먼저, 필요한 종속성을 추가해야 합니다.

pom.xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
    

3.1. application.yml 설정

OAuth2 인증 프로바이더의 정보와 클라이언트 정보를 설정 파일에 추가합니다. 일반적으로 Google과 같은 소셜 로그인 제공자의 정보를 설정합니다.

application.yml
spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: YOUR_CLIENT_ID
            client-secret: YOUR_CLIENT_SECRET
            scope: profile, email
            redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
        provider:
          google:
            authorization-uri: https://accounts.google.com/o/oauth2/auth
            token-uri: https://oauth2.googleapis.com/token
            user-info-uri: https://www.googleapis.com/userinfo
            user-name-attribute: sub
    

3.2. 보안 설정

스프링 시큐리티를 사용하여 보안 설정을 적용합니다.

WebSecurityConfig.java
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/", "/login").permitAll() // 모든 사용자에게 / 및 /login 접근 허용
            .anyRequest().authenticated() // 나머지 모든 요청은 인증 필요
            .and()
            .oauth2Login(); // OAuth2 로그인 지원
    }
}
    

4. 로그인 및 로그아웃 처리하기

이제 기본적인 로그인 및 로그아웃 기능을 구현할 수 있습니다. 사용자가 /login URL에 접근했을 때, OAuth2 제공자를 통해 인증을 시도합니다. 인증이 성공적으로 완료되면, 사용자는 주요 대시보드로 리다이렉션 됩니다.

4.1. 로그인 페이지

인증 버튼을 포함한 간단한 로그인 페이지를 만들어 봅시다.

login.html
<html>
<head>
  <title>로그인 페이지</title>
</head>
<body>
  <h1>로그인</h1>
  <a href="/oauth2/authorization/google">구글로 로그인</a> 
</body>
</html>
    

4.2. 로그아웃

로그아웃 처리를 위해 추가적인 설정이 필요합니다.

WebSecurityConfig.java
@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .authorizeRequests()
        .antMatchers("/", "/login", "/logout").permitAll()
        .anyRequest().authenticated()
        .and()
        .oauth2Login()
        .and()
        .logout()
        .logoutSuccessUrl("/"); // 로그아웃 후 홈으로 리다이렉트
}
    

5. 권한 부여 코드 승인 타입이란?

OAuth2는 여러 가지 승인 타입(Grant Types)을 제공하며, 그 중에서도 가장 인기 있는 방식 중 하나가 바로 권한 부여 코드 방식(Authorization Code Grant)입니다.

5.1. 권한 부여 코드 승인 타입 설명

권한 부여 코드 방식은 일반적으로 다음과 같은 흐름을 따릅니다:

  • 사용자가 클라이언트 애플리케이션에서 로그인 버튼을 클릭합니다.
  • 클라이언트 애플리케이션은 사용자에게 OAuth2 서버의 인증 화면으로 리다이렉트합니다.
  • 사용자는 인증 정보를 입력하고 이를 OAuth2 서버에 전달합니다.
  • OAuth2 서버는 사용자가 인증되면, 권한 부여 코드를 클라이언트에 전달합니다.

5.2. 권한 부여 코드의 장점

권한 부여 코드 방식의 주요 장점은 다음과 같습니다:

  • 주요 보안 수준: 권한 부여 코드는 클라이언트 비밀과 함께 서버에만 저장되므로, 리소스 서버와의 통신 과정에서 더 안전합니다.
  • 리프레시 토큰 지원: 액세스 토큰이 만료되면 리프레시 토큰을 통해 새로 고칠 수 있습니다.

6. 마무리

이번 강좌에서는 스프링 부트를 이용해 OAuth2를 통한 로그인 및 로그아웃 기능을 구현하는 방법과 권한 부여 코드 승인 타입에 대해 알아보았습니다. OAuth2는 현대 웹 애플리케이션에서 필수적인 인증 및 권한 부여 프로토콜로, 보안성과 사용자 편의성을 제공하기 위한 중요한 도구입니다. 사용자의 필요에 맞게 다양한 인증 방법을 조합하여 더 안전하고 편리한 서비스를 만들 수 있습니다.

추천 자료

스프링 부트 백엔드 개발 강좌, OAuth2로 로그인 로그아웃 구현, OAuth2 실행 테스트하기

오늘날 웹 애플리케이션에서 인증과 권한 부여는 매우 중요한 요소이며, OAuth2는 이를 구현하는 데 널리 사용되는 표준입니다. 본 강좌에서는 스프링 부트를 사용하여 OAuth2 기반의 로그인 및 로그아웃 기능을 구현하는 방법에 대해 자세히 알아보겠습니다. 이 강좌의 목표는 스프링 부트 애플리케이션에서 OAuth2를 통해 안전한 인증 방식을 적용하고, 이를 테스트하는 방법을 배우는 것입니다.

1. OAuth2란?

OAuth2(오AUTH 2.0)는 인터넷 사용자들이 제3자 애플리케이션에 자신의 정보를 노출하지 않고도 다른 서비스에서 자신의 계정을 사용할 수 있도록 허용하는 권한 부여 프레임워크입니다. 기본적으로 OAuth2는 엑세스 토큰을 기반으로 작업하며, 이 토큰을 통해 사용자는 자신의 데이터에 접근할 수 있습니다. 이 과정에서 사용자의 비밀번호를 공유할 필요가 없습니다.

1.1 OAuth2의 구성 요소

  • Resource Owner: 자원 소유자, 일반적으로 사용자입니다.
  • Client: 자원 소유자가 서비스를 요청하는 애플리케이션입니다.
  • Authorization Server: 클라이언트의 요청을 인증하고 동의 후 엑세스 토큰을 발급하는 서버입니다.
  • Resource Server: 보호된 자원(예: 사용자 데이터)에 접근할 수 있는 서버입니다.

1.2 OAuth2 흐름

OAuth2의 인증 흐름은 다음과 같이 진행됩니다:

  1. 사용자가 클라이언트를 통해 Authorization Server에 인증 요청을 보냅니다.
  2. 사용자가 인증을 성공적으로 수행하면 Authorization Server는 클라이언트에 엑세스 토큰을 발급합니다.
  3. 클라이언트는 발급받은 엑세스 토큰을 Resource Server에 전송하여 보호된 자원에 접근합니다.

2. 스프링 부트 환경 설정

스프링 부트 환경을 설정하기 위해서는 먼저 필요한 의존성을 추가해야 합니다. 이를 위해 먼저 Spring Initializr를 활용하여 프로젝트를 생성합니다.

2.1 Spring Initializr에서 프로젝트 생성하기

다음과 같은 설정으로 스프링 부트 프로젝트를 생성합니다:

  • Project: Maven Project
  • Language: Java
  • Spring Boot: 2.6.3 (최신 버전을 선택합니다)
  • Dependencies: Spring Web, Spring Security, Spring Data JPA, H2 Database

2.2 pom.xml 파일 수정하기

다음으로, pom.xml 파일에 OAuth2 관련 의존성을 추가합니다:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-client</artifactId>
    </dependency>
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
    </dependency>
    

3. OAuth2 설정

OAuth2을 설정하기 위해 application.yml 파일을 수정하여 Authorization Server와 Resource Server 정보를 입력합니다.

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: YOUR_CLIENT_ID
            client-secret: YOUR_CLIENT_SECRET
            scope:
              - profile
              - email
            redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
        provider:
          google:
            authorization-uri: https://accounts.google.com/o/oauth2/auth
            token-uri: https://oauth2.googleapis.com/token
            user-info-uri: https://www.googleapis.com/oauth2/v3/userinfo
            user-name-attribute: sub
  

4. 스프링 시큐리티 설정

스프링 시큐리티를 설정하여 인증과 인가를 처리합니다. 다음은 기본적인 시큐리티 설정 클래스 예제입니다:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/login").permitAll()
                .anyRequest().authenticated()
                .and()
            .oauth2Login();
    }
}

5. 사용자 정보 가져오기

사용자가 인증에 성공하면, OAuth2 클라이언트를 통해 사용자 정보를 가져옵니다. 이를 위해 컨트롤러를 만듭니다.

import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.oauth2.core.user.OAuth2User;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @GetMapping("/user")
    public OAuth2User getUser(@AuthenticationPrincipal OAuth2User principal) {
        return principal;
    }
}

6. 테스트 및 실행

애플리케이션을 실행하고 웹 브라우저에서 http://localhost:8080에 접근합니다. 사용자는 로그인 버튼을 클릭하여 Google 로그인 페이지로 리디렉션됩니다. 로그인 후, /user 경로를 통해 자신의 사용자 정보를 확인할 수 있습니다.

결론

이번 강좌에서는 스프링 부트를 사용하여 OAuth2를 통해 로그인 및 로그아웃 기능을 구현하는 방법을 살펴보았습니다. 이 과정에서 OAuth2의 기본 개념, 필요한 의존성 설정, 스프링 시큐리티 설정 및 사용자 정보 가져오기를 배웠습니다. 이러한 과정을 통해 여러분의 웹 애플리케이션에 보다 안전한 로그인 기능을 추가할 수 있게 되었습니다.

참고 문헌